2D-Grafik Linie wird nach Mausklick nicht am richtigen Ort gezeichnet

[Josie]

Hallo

Eine bestimmte Anzahl von Kreisen werden gezeichnet. Danach möchte ich eine Linie zwischen zwei Kreisen nach einem Mausklick ziehen. Die Liste mit allen Kreisen wird mit den Koordinaten des Mausklicks verglichen. Wenn ein Kreis gefunden wird, wird eine Linie gezeichnet.

Mein Problem ist, dass irgendwie die Koordinaten nicht übereinstimmen. D.h. schon das Anklicken eines Kreises klappt nicht. Und wenn ich dann zufällig irgendwo was treffe, zeichnet mir die Linie auch nicht dort, wo ich die Maus hatte, sondern ganz wo anders.
Ich vermute, dass es daran liegt, dass ich beim Zeichnen translate() verwende.

Vielleicht findet jemand meinen Fehler oder hat einen Tipp.

Hier mein Code:

public class Spielfeld extends JPanel{

   
    private int startX;
    private int startY;
    private int endX;
    private int endY;
    private int[][] spielfeld;
    private ArrayList<Insel> listInseln;
    private ArrayList<Bruecke> listBruecken;
    private ArrayList<Bruecke> listGezeichneteBruecken;

    private int d=38;
    public static final int ABSTAND = 80;
    public static final int DURCHMESSER=80;
    Insel insel;
    Insel nextInsel;
    Bruecke brueckeNeu;

    public Spielfeld(ArrayList<Insel> listInseln, ArrayList<Bruecke> listBruecken) {
        this.listBruecken=listBruecken;
        this.listInseln = listInseln;

        listGezeichneteBruecken= new ArrayList<Bruecke>();


        setSpielfeld(new int[Generator.breite][Generator.hoehe]);
        spielfeldInitialisieren();

        repaint();

       

        addMouseListener(new MouseAdapter() {
            @Override
            public void mouseClicked(MouseEvent e) {
                if (SwingUtilities.isLeftMouseButton(e))
                {
                    // x- und y- Wert des Mausklicks
                    startX = e.getX();
                    startY = e.getY();
                    if (isInsideNord(startX, startY)) {
                        nextInsel=insel.naechsteInselNord(insel, listInseln);
                        brueckeNeu = new Bruecke(nextInsel.getId(), insel.getId(), listGezeichneteBruecken, nextInsel.getPosInselX(), nextInsel.getPosInselY(), insel.getPosInselX(), insel.getPosInselY(), false);
                        brueckeNeu.setzeBruecke(brueckeNeu, listGezeichneteBruecken);
                 
                    }

                    else if (isInsideOst(startX, startY)){
                        nextInsel=insel.naechsteInselOst(insel, listInseln);
                        brueckeNeu = new Bruecke(insel.getId(), nextInsel.getId(), listGezeichneteBruecken, insel.getPosInselX(), insel.getPosInselY(), nextInsel.getPosInselX(), nextInsel.getPosInselY(), false);
                        brueckeNeu.setzeBruecke(brueckeNeu, listGezeichneteBruecken);
                      
                    }

                    else if (isInsideSued(startX, startY)){
                        nextInsel=insel.naechsteInselSued(insel, listInseln);
                        brueckeNeu = new Bruecke(insel.getId(), nextInsel.getId(), listGezeichneteBruecken, insel.getPosInselX(), insel.getPosInselY(), nextInsel.getPosInselX(), nextInsel.getPosInselY(), false);
                        brueckeNeu.setzeBruecke(brueckeNeu, listGezeichneteBruecken);
                      
                    }

                    else if (isInsideWest(startX, startY)) {
                        nextInsel=insel.naechsteInselWest(insel, listInseln);
                        brueckeNeu = new Bruecke(nextInsel.getId(), insel.getId(), listGezeichneteBruecken, nextInsel.getPosInselX(), nextInsel.getPosInselY(), insel.getPosInselX(), insel.getPosInselY(), false);
                        brueckeNeu.setzeBruecke(brueckeNeu, listGezeichneteBruecken);
                       
                    }
                   


                }
                if (SwingUtilities.isRightMouseButton(e))
                {



                }
              
                endX=nextInsel.getPosInselX();
                endY=nextInsel.getPosInselY();
             
                //brueckeNeu.setzeBruecke(brueckeNeu, listGezeichneteBruecken);
               
               
                repaint();


            }
        });



    }

    // Raster zeichnen
    @Override
    public void paintComponent(Graphics g) {
        //super.paintComponent(g);

        g.translate(ABSTAND, ABSTAND);
       
        zeichneInsel(g);
        if(listGezeichneteBruecken.size()>0) {
            zeichneBruecke(g);
        }
      

    }

    private void zeichneInsel(Graphics g) {
        for(Insel ins:listInseln) {

            String s = String.valueOf(ins.getAnzBruecken());
          
            g.drawString(s, spielfeld[ins.getPosInselX()][ins.getPosInselY()]+ ABSTAND*ins.getPosInselX(), spielfeld[ins.getPosInselX()][ins.getPosInselY()]+ABSTAND*ins.getPosInselY());
            g.drawOval(spielfeld[ins.getPosInselX()][ins.getPosInselY()]+ ABSTAND*ins.getPosInselX(), spielfeld[ins.getPosInselX()][ins.getPosInselY()]+ABSTAND*ins.getPosInselY(), DURCHMESSER/2, DURCHMESSER/2);

          
        }

    }


    private void zeichneBruecke(Graphics g) {
       

        berechneStandortBruecke(endX, endY);
        System.out.println("Brücke: " +startX +", "+startY +" und " +endX +", " +endY);
      

        g.setColor(Color.PINK);
        g.drawLine(startX, startY, endX, endY);
     
    }


    // Spielfeld initialisieren
    private void spielfeldInitialisieren() {
      
        for (int i = 0; i < Generator.breite; i++) {
            for (int y = 0; y < Generator.hoehe; y++) {
                spielfeld[i][y] = 0;
            }
        }
    }


    void berechneStandortBruecke(int x2, int y2) {
       
        endX = x2 * ABSTAND  +DURCHMESSER/2;
        endY = y2 * ABSTAND  + DURCHMESSER/2;
    }


    /**
     *  Prüft, ob der Mausklick der Klicksektor "Nord" trifft und gibt die gefundene Insel an.
     *  
     * @param mausX X-Wert der Maus beim Klicken
     * @param mausY Y-Wert der Maus beim Klicken
     * @return true, wenn Mausklick im Klicksektor Nord trifft
     */

    boolean isInsideNord(int mausX, int mausY) {
        boolean isInside=false;
        //mittelpunktX

        //for(Insel i: listInseln) {
        for(int i=0; i<listInseln.size(); i++) {
            if((listInseln.get(i).getPosInselX()*ABSTAND  + DURCHMESSER/2) - d < mausX && mausX < (listInseln.get(i).getPosInselX()*ABSTAND  + DURCHMESSER/2) + d
                    && (listInseln.get(i).getPosInselY()*ABSTAND + DURCHMESSER/2) > mausY && mausY > (listInseln.get(i).getPosInselY()*ABSTAND + DURCHMESSER/2) - d
                    && Math.abs(mausX-(listInseln.get(i).getPosInselX()*ABSTAND + DURCHMESSER/2)) < Math.abs(mausY - (listInseln.get(i).getPosInselY()*ABSTAND + DURCHMESSER/2))) {
                insel=listInseln.get(i);
                return isInside=true;
            }
        }

        return isInside;
    }


    /**
     *  Prüft, ob der Mausklick der Klicksektor "Ost" trifft und gibt die gefundene Insel an.
     *  
     * @param mausX X-Wert der Maus beim Klicken
     * @param mausY Y-Wert der Maus beim Klicken
     * @return true, wenn Mausklick im Klicksektor Ost trifft
     */

    boolean isInsideOst(int mausX, int mausY) {
        boolean isInside=false;

        //for(Insel i: listInseln) {
        for(int i=0; i<listInseln.size(); i++) {
            if((listInseln.get(i).getPosInselX()*ABSTAND + DURCHMESSER/2) < mausX && mausX < (listInseln.get(i).getPosInselX()*ABSTAND + DURCHMESSER/2) + d
                    && (listInseln.get(i).getPosInselY()*ABSTAND + DURCHMESSER/2) -d < mausY && mausY < (listInseln.get(i).getPosInselY()*ABSTAND + DURCHMESSER/2) + d
                    && Math.abs(mausY - (listInseln.get(i).getPosInselY()*ABSTAND + DURCHMESSER/2)) < Math.abs(mausX - (listInseln.get(i).getPosInselX()*ABSTAND + DURCHMESSER/2))) {
                insel=listInseln.get(i);
                return isInside=true;
            }
        }
        return isInside;
    }


    /**
     *  Prüft, ob der Mausklick der Klicksektor "Süd" trifft und gibt die gefundene Insel an.
     *  
     * @param mausX X-Wert der Maus beim Klicken
     * @param mausY Y-Wert der Maus beim Klicken
     * @return true, wenn Mausklick im Klicksektor Süd trifft
     */


    boolean isInsideSued(int mausX, int mausY) {
        boolean isInside=false;

        //for(Insel i:listInseln) {
        for(int i=0; i<listInseln.size(); i++) {
            if((listInseln.get(i).getPosInselX()*ABSTAND + DURCHMESSER/2) < mausX && mausX < (listInseln.get(i).getPosInselX()*ABSTAND + DURCHMESSER/2) +d
                    && (listInseln.get(i).getPosInselY()*ABSTAND + DURCHMESSER/2) -d < mausY && mausY < (listInseln.get(i).getPosInselY()*ABSTAND + DURCHMESSER/2) +d
                    && Math.abs(mausY - (listInseln.get(i).getPosInselY()*ABSTAND + DURCHMESSER/2)) > Math.abs(mausX - (listInseln.get(i).getPosInselX()*ABSTAND + DURCHMESSER/2))) {
                insel=listInseln.get(i);
                return isInside=true;
            }
        }
        return isInside;
    }


    /**
     *  Prüft, ob der Mausklick der Klicksektor "West" trifft und gibt die gefundene Insel an.
     *  
     * @param mausX X-Wert der Maus beim Klicken
     * @param mausY Y-Wert der Maus beim Klicken
     * @return true, wenn Mausklick im Klicksektor West trifft
     */

    boolean isInsideWest(int mausX, int mausY) {
        boolean isInside=false;

        //for(Insel i:listInseln) {
        for(int i=0; i<listInseln.size(); i++) {
            if((listInseln.get(i).getPosInselX()*ABSTAND + DURCHMESSER/2) > mausX && mausX > (listInseln.get(i).getPosInselX()*ABSTAND + DURCHMESSER/2) -d
                    && (listInseln.get(i).getPosInselY()*ABSTAND + DURCHMESSER/2) -d < mausY && mausY < (listInseln.get(i).getPosInselY()*ABSTAND + DURCHMESSER/2) +d
                    && Math.abs(mausX -(listInseln.get(i).getPosInselX())*ABSTAND + DURCHMESSER/2) > Math.abs(mausY -(listInseln.get(i).getPosInselY()*ABSTAND + DURCHMESSER/2))) {
                insel=listInseln.get(i);
                return isInside=true;
            }
        }
        return isInside;
    }

 

[JCODA]

Ich würd's mir anschauen, aber ich hab keine Lust jede Zeile durchzugehen, deshalb: Wenn du möchtest, dass ich mich genauer damit beschäftige müsstest du mir eine compilierbare Version zusammenstellen.

 

[Josie]

ja gerne.

ich geb dir mal alle Klasse an, die du benötigst:

Aber bitte beachte, wenn du ein neues Rätsel startest (Menüpunkt "neues Rätsel"): es gibt noch einen Fehler in der Generierung, am besten wählst du eine Grösse 5x5 und 5 Inseln.

Main-Klasse mit der Gui-Umgebung:

package gui;

import rechner.*;

import java.awt.*;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;
import javax.swing.*;

import java.awt.GridLayout;

import javax.swing.JButton;

import java.awt.BorderLayout;
import java.awt.event.*;
import java.io.*;

/**
*
* @author
*
*/

// Hauptfenster
public class BridgesMainGui extends JFrame implements ActionListener {
    JButton button;
    RaetselDialog raetselDialog;
    JPanel zeichenflaeche;
    Generator generator;
    Spielfeld spielfeld;
    private File lastPath;
     JFileChooser fc;
    int breite;

     String path; // für Pfad anzeigen

     JPanel contentPanel;

     JMenuItem mntmNeuesRtsel, mntmRtselNeuStarten, mntmRtselLaden, mntmRtselSpeichern, mntmRtselSpeichernUnter, mntmBeenden;

   
   
   
   
    public BridgesMainGui() {

        initComponents();

    }
   
   
   
    private void initComponents(){  
        setTitle("Katrin Schläpfer / M-Nr. 9241108");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setBounds(100, 100, 600, 500);

        // FileChooser
        fc = new JFileChooser();
        fc.setFileSelectionMode(JFileChooser.FILES_ONLY); // Anzeige-Modus
        fc.setCurrentDirectory(new File(System.getProperty("user.home")));

        // Menüleiste
        JMenuBar menuBar = new JMenuBar();
        setJMenuBar(menuBar);

        JMenu menu = new JMenu("Datei");
        menuBar.add(menu);

        mntmNeuesRtsel = new JMenuItem("Neues Rätsel");
        menu.add(mntmNeuesRtsel);
        mntmNeuesRtsel.addActionListener(this); // Beobachter registrieren

        mntmRtselNeuStarten = new JMenuItem("Rätsel neu starten");
        mntmRtselNeuStarten.addActionListener(this);
        menu.add(mntmRtselNeuStarten);

        mntmRtselLaden = new JMenuItem("Rätsel laden");
        mntmRtselLaden.addActionListener(this);// Beobachter registrieren
        menu.add(mntmRtselLaden);

        mntmRtselSpeichern = new JMenuItem("Rätsel speichern");
        mntmRtselSpeichern.addActionListener(this); // Beobachter registrieren
        menu.add(mntmRtselSpeichern);

        mntmRtselSpeichernUnter = new JMenuItem("Rätsel speichern unter");
        mntmRtselSpeichernUnter.addActionListener(this);
        menu.add(mntmRtselSpeichernUnter);

        mntmBeenden = new JMenuItem("Beenden");
        mntmBeenden.addActionListener(this); // Beobachter registrieren
        menu.add(mntmBeenden);

        // CENTER
        zeichenflaeche = new JPanel(new BorderLayout());
        zeichenflaeche.setBackground(Color.WHITE);
        //zeichenflaeche.addMouseListener(this);
        //zeichenflaeche.setPreferredSize(new Dimension(600,500));
        JScrollPane jsp = new JScrollPane(zeichenflaeche);

      
        // SOUTH
        JPanel southPanel = new JPanel();
        southPanel.setLayout(new GridLayout(3, 1));

        JPanel checkboxPanel = new JPanel(new FlowLayout(FlowLayout.LEFT));
        JCheckBox checkbox = new JCheckBox("Anzahl fehlender Brücken anzeigen");
        checkboxPanel.add(checkbox);

        JPanel buttonPanel = new JPanel();
        buttonPanel.setLayout(new GridLayout(1, 2));
        JButton buttonLoesen = new JButton("Automatisch lösen");
        JButton buttonNaechsteBruecke = new JButton("Nächste Brücke");
        buttonPanel.add(buttonLoesen);
        buttonPanel.add(buttonNaechsteBruecke);

        JPanel statusPanel = new JPanel();
        statusPanel.setLayout(new FlowLayout((FlowLayout.LEFT)));
        JLabel status = new JLabel();
        statusPanel.add(status);

        southPanel.add(checkboxPanel);
        southPanel.add(buttonPanel);
        southPanel.add(statusPanel);

        // Hauptpanel (alle Komponenten zusammenfügen)
        contentPanel = new JPanel();
        //jsp.add(contentPanel);
        //contentPanel.add(jsp);
        contentPanel.setBorder(new EmptyBorder(5, 5, 5, 5));
        setContentPane(contentPanel);
        contentPanel.setLayout(new BorderLayout());
        contentPanel.add(BorderLayout.CENTER, zeichenflaeche);

        contentPanel.add(BorderLayout.SOUTH, southPanel);

        raetselDialog = new RaetselDialog(this); // Dialogfenster erzeugen
        setVisible(true);
    }

    // Neues Rätsel generieren: Öffnet zuerst das Dialogfenster auf
    @Override
    public void actionPerformed(ActionEvent e) {
       
        // neues Rätsel generieren
        if (e.getSource() == mntmNeuesRtsel) {
            neuesSpielStarten();
          
            // newGame.start();

        }
       
        // Öffnet Datei zum Spiel laden
        if (e.getSource() == mntmRtselLaden) {

            fc.setCurrentDirectory(lastPath); // letzter Pfad setzen


            int returnVal = fc.showOpenDialog(this);
            if (returnVal == JFileChooser.APPROVE_OPTION) {

                File file = fc.getSelectedFile();
                lastPath=file.getParentFile();
                if(lastPath != null)
                    fc.setCurrentDirectory(lastPath);


                path= file.getAbsolutePath(); // Pfad der Datei zum Parser übergeben

                Parser parser = new Parser(path);
                //////////////////////////////////// Spielfeld   ///////
                zeichenflaeche.removeAll();
                spielfeld=new Spielfeld(parser.getinselListeP(), parser.getlistBrueckenP());
                zeichenflaeche.add(spielfeld, BorderLayout.CENTER);
                //zeichenflaeche.add(generator, BorderLayout.CENTER);
                zeichenflaeche.revalidate();
                zeichenflaeche.repaint();
            }

           
            //fc.setVisible(false);

        }


        // Rätsel speichern
        if (e.getSource() == mntmRtselSpeichern) {


                    new Parser(path, spielfeld.getListInseln(), spielfeld.getListBruecken());
               

        }


        // Das Spiel wird unter gewählten Namen gespeichert
        if (e.getSource() == mntmRtselSpeichernUnter) {


            fc.setCurrentDirectory(lastPath); // letzter Pfad setzen
            fc.setSelectedFile(new File(Generator.breite + "x" + Generator.hoehe +".bgs")); // Dateiname vorgeben

            int returnVal = fc.showSaveDialog(this);



            if (returnVal == JFileChooser.APPROVE_OPTION) {



                File file = fc.getSelectedFile();


                lastPath=file.getParentFile();
                if(lastPath != null)
                    fc.setCurrentDirectory(lastPath);


                path=file.getAbsolutePath();
                if(!file.exists() ||
                        JOptionPane.showConfirmDialog(this, "Möchten Sie die vorhandene Datei überschreiben?",
                                "Datei existiert bereits",
                                JOptionPane.YES_NO_OPTION) == JOptionPane.YES_OPTION) {


                    new Parser(path, spielfeld.getListInseln(), spielfeld.getListBruecken());
                }

                //fc.setVisible(false);
            }
            // fc.setVisible(false);
        }
       
        // Spiel beenden
        if (e.getSource() == mntmBeenden) {
            System.exit(0);

        }
    }

    public static void main(String[] args) {
        java.awt.EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                new BridgesMainGui();
            }
        });

    }

/**
* Startet das Dialogfenster, um Breite, Höhe und Anzahl Inseln zu bestimmen
*/
  
    void neuesSpielStarten() {
        raetselDialog.showDialog(); // Dialogfenster anzeigen
        if(!raetselDialog.okGedrueckt) // auf Abbrechen geklickt: es wird nichts gezeichnet
            return;
        else {
        zeichenflaeche.removeAll();
       
        // Das Spiel wird generiert
        generator = new Generator(raetselDialog.breite, raetselDialog.hoehe, raetselDialog.insel);
        // und auf dem Spielfeld angezeigt
        spielfeld=new Spielfeld(generator.getListInseln(), Generator.getListBruecken());
        zeichenflaeche.add(spielfeld, BorderLayout.CENTER);
       
       
        zeichenflaeche.revalidate();
        zeichenflaeche.repaint();
        }
    }

}

Die Klasse Generator um ein Rätsel zu generieren:

package rechner;

import java.awt.*;
import java.util.*;

import javax.swing.JPanel;

import root.*;
import gui.*;

public class Generator extends JPanel  {
    
    public static int hoehe; // für die Übergabe der Höhe aus dem Dialogfenster
    public static int breite; // für die Übergabe der Breite aus dem Dialogfenster
    public static int maximum; // für die Übergabe der Anzahl Inseln aus dem Dialogfenster
    public static int countAnzInsel; //= 0; // zählt die Anzahl der Inseln hoch

   
    static Random r = new Random();

    Insel neueInsel;
    Spielfeld spielfeld;

    // Liste mit Positionen der Inseln
    private ArrayList<Insel> listInseln;
    private static ArrayList<Bruecke> listBruecken=null;
    private static ArrayList<Insel>waehlbareInselnListe = null;
    private static ArrayList<Insel>nichtWaehlbareInselnListe = null;

    public Generator(String strBreite, String strHoehe, String strcountAnzInsel) {

        hoehe = Integer.parseInt(strHoehe);
        breite = Integer.parseInt(strBreite);
        maximum = Integer.parseInt(strcountAnzInsel);
      

        generiere();
       
         spielfeld=new Spielfeld(listInseln, listBruecken);  // Übergabe zum Brückenzeichnen
       
       

    }

    public Generator() {
        // automatisch();

    }

    

    public void generiere() {
        listInseln = new ArrayList<Insel>();
        listBruecken = new ArrayList<Bruecke>();
        waehlbareInselnListe= new ArrayList<Insel>();
        nichtWaehlbareInselnListe = new ArrayList<Insel>();
        countAnzInsel=0;
       
        // 1. zufällige Position der Insel bestimmen und setzen
        int posX = 0;
        int posY = 0;
       

       
            posX = r.nextInt(breite - 1) + 1;

            posY = r.nextInt(hoehe - 1) + 1;
            int id = 0;
            int anzBruecken = 0;

            neueInsel = new Insel(posX, posY, listInseln, id, anzBruecken, true, true, true, true);
            // in Liste aufnehmen
            neueInsel.setzeInsel(neueInsel, listInseln, waehlbareInselnListe);
            //spielfeld[posX][posY] = 1;
            countAnzInsel++;
          
            while (countAnzInsel <maximum ) {
                if( waehlbareInselnListe.size() > 0  )
                    neueInsel.weitereInselnBestimmen(neueInsel);
                else {
                    System.out.println("generiere()");
                    generiere();
                   
                }
               
               
           
        }
           
            for (Insel g:listInseln) {
                System.out.println("Insel: " + g.getId() + ": " + g.getPosInselX() + " - " + g.getPosInselY());
            }

           

    }
   
/
    ArrayList<Insel> listeAllerInseln() {
        return new ArrayList<Insel>(listInseln);
    }

    public ArrayList<Insel> getListInseln() {
        return listInseln;
    }

    public void setListInseln(ArrayList<Insel> listInseln) {
        this.listInseln = listInseln;
    }


    public static ArrayList<Bruecke> getListBruecken() {
        return listBruecken;
    }

    public static void setListBruecken(ArrayList<Bruecke> listBruecken) {
        Generator.listBruecken = listBruecken;
    }

    


    public static ArrayList<Insel> getwaehlbareInselnListe() {
        return waehlbareInselnListe;
    }

    public static void setwaehlbareInselnListe(
            ArrayList<Insel> waehlbareInselnListe) {
        Generator.waehlbareInselnListe = waehlbareInselnListe;
    }

    public static ArrayList<Insel> getNichtWaehlbareInselnListe() {
        return nichtWaehlbareInselnListe;
    }

    public static void setNichtWaehlbareInselnListe(
            ArrayList<Insel> nichtWaehlbareInselnListe) {
        Generator.nichtWaehlbareInselnListe = nichtWaehlbareInselnListe;
    }
   
   
}

Die Klasse Bruecke:

package root;

import java.util.ArrayList;

public class Bruecke implements Comparable<Bruecke>{
    private int startInselID;
    private int endInselID;
   
    private int startInselx;
    private int startInsely;
    private int endInselx;
    private int endInsely;
    private boolean doppelbruecke;
   
    private ArrayList<Bruecke> listeBruecken;

    public Bruecke(int startInselID, int endInselID, ArrayList<Bruecke> listeBruecken, int startInselx, int startInsely, int endInselx,int  endInsely, boolean doppelbruecke) {
        this.startInselID = startInselID;
        this.endInselID = endInselID;
        this.listeBruecken = listeBruecken;
        this.startInselx = startInselx;
        this.startInsely = startInsely;
        this.endInselx = endInselx;
        this.endInsely = endInsely;
        this.doppelbruecke = doppelbruecke;
    }
   
   
   
   
   
    public ArrayList<Bruecke> setzeBruecke(Bruecke setzendeBruecken, ArrayList<Bruecke> alleBruecken) {
        alleBruecken.add(setzendeBruecken);
        return alleBruecken;
    }
   

    public int getStartInselID() {
        return startInselID;
    }

    public int getEndInselID() {
        return endInselID;
    }

    public int getStartInselx() {
        return startInselx;
    }








    public int getStartInsely() {
        return startInsely;
    }








    public int getEndInselx() {
        return endInselx;
    }








    public int getEndInsely() {
        return endInsely;
    }








    public void setStartInselx(int startInselx) {
        this.startInselx = startInselx;
    }








    public void setStartInsely(int startInsely) {
        this.startInsely = startInsely;
    }








    public void setEndInselx(int endInselx) {
        this.endInselx = endInselx;
    }








    public void setEndInsely(int endInsely) {
        this.endInsely = endInsely;
    }








    public boolean isDoppelbruecke() {
        return doppelbruecke;
    }





    public void setDoppelbruecke(boolean doppelbruecke) {
        this.doppelbruecke = doppelbruecke;
    }





    public ArrayList<Bruecke> getListeBruecken() {
        return listeBruecken;
    }

    public void setStartInselID(int startInselID) {
        this.startInselID = startInselID;
    }

    public void setEndInselID(int endInselID) {
        this.endInselID = endInselID;
    }

    public void setListeBruecken(ArrayList<Bruecke> listeBruecken) {
        this.listeBruecken = listeBruecken;
    }




    @Override
    public int compareTo(Bruecke bruecke)
    {
        if (getStartInselID() != bruecke.getStartInselID() ) {
            return getStartInselID() - bruecke.getStartInselID();
        }
        else if (getEndInselID() != bruecke.getEndInselID() ) {
            return getEndInselID() - bruecke.getEndInselID();
        }
        else
            return 0;
       
       
    }
   



   
}

und die Klasse Spielfeld, wo gezeichnet werden soll:

package rechner;

import java.awt.*;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.ArrayList;

import root.*;
import gui.*;

import javax.swing.JPanel;
import javax.swing.SwingUtilities;

public class Spielfeld extends JPanel{


    private int startX;
    private int startY;
    private int endX;
    private int endY;
    private int mittelpunktX;
    private int mittelpunktY;
    private int[][] spielfeld;
    //private int[][] spielfeld = generator.getSpielfeld();
    private ArrayList<Insel> listInseln;
    private ArrayList<Bruecke> listBruecken;
    private ArrayList<Bruecke> listGezeichneteBruecken;

    private int d=38;//10;
    public static final int ABSTAND = 80;//22;
    public static final int DURCHMESSER=80;//22;
    Insel insel;
    Insel nextInsel;
    Bruecke brueckeNeu;

    public Spielfeld(ArrayList<Insel> listInseln, ArrayList<Bruecke> listBruecken) {
        this.listBruecken=listBruecken;
        this.listInseln = listInseln;

        listGezeichneteBruecken= new ArrayList<Bruecke>();


        setSpielfeld(new int[Generator.breite][Generator.hoehe]);
        spielfeldInitialisieren();

        repaint();



        addMouseListener(new MouseAdapter() {
            @Override
            public void mouseClicked(MouseEvent e) {
                if (SwingUtilities.isLeftMouseButton(e))
                {
                    // x- und y- Wert des Mausklicks
                    //e.translatePoint(ABSTAND, ABSTAND);
                    startX = e.getX();
                    startY = e.getY();
                    if (isInsideNord(startX, startY)) {
                        nextInsel=insel.naechsteInselNord(insel, listInseln);
                        brueckeNeu = new Bruecke(nextInsel.getId(), insel.getId(), listGezeichneteBruecken, nextInsel.getPosInselX(), nextInsel.getPosInselY(), insel.getPosInselX(), insel.getPosInselY(), false);
                        brueckeNeu.setzeBruecke(brueckeNeu, listGezeichneteBruecken);
                        System.out.println("InselN: " +insel.getPosInselX() +", " +insel.getPosInselY() +" und " +nextInsel.getPosInselX() +", " +nextInsel.getPosInselY());
                        System.out.println("BrückeN: " +brueckeNeu.getStartInselx() +", " +brueckeNeu.getStartInsely() +" und " +brueckeNeu.getEndInselx() +", " +brueckeNeu.getEndInsely());
                    }

                    else if (isInsideOst(startX, startY)){
                        nextInsel=insel.naechsteInselOst(insel, listInseln);
                        brueckeNeu = new Bruecke(insel.getId(), nextInsel.getId(), listGezeichneteBruecken, insel.getPosInselX(), insel.getPosInselY(), nextInsel.getPosInselX(), nextInsel.getPosInselY(), false);
                        brueckeNeu.setzeBruecke(brueckeNeu, listGezeichneteBruecken);
                        System.out.println("InselO: " +insel.getPosInselX() +", " +insel.getPosInselY() +" und " +nextInsel.getPosInselX() +", " +nextInsel.getPosInselY());
                        System.out.println("BrückeO: " +brueckeNeu.getStartInselx() +", " +brueckeNeu.getStartInsely() +" und " +brueckeNeu.getEndInselx() +", " +brueckeNeu.getEndInsely());
                    }

                    else if (isInsideSued(startX, startY)){
                        nextInsel=insel.naechsteInselSued(insel, listInseln);
                        brueckeNeu = new Bruecke(insel.getId(), nextInsel.getId(), listGezeichneteBruecken, insel.getPosInselX(), insel.getPosInselY(), nextInsel.getPosInselX(), nextInsel.getPosInselY(), false);
                        brueckeNeu.setzeBruecke(brueckeNeu, listGezeichneteBruecken);
                        System.out.println("InselS: " +insel.getPosInselX() +", " +insel.getPosInselY() +" und " +nextInsel.getPosInselX() +", " +nextInsel.getPosInselY());
                        System.out.println("BrückeS: " +brueckeNeu.getStartInselx() +", " +brueckeNeu.getStartInsely() +" und " +brueckeNeu.getEndInselx() +", " +brueckeNeu.getEndInsely());
                    }

                    else if (isInsideWest(startX, startY)) {
                        nextInsel=insel.naechsteInselWest(insel, listInseln);
                        brueckeNeu = new Bruecke(nextInsel.getId(), insel.getId(), listGezeichneteBruecken, nextInsel.getPosInselX(), nextInsel.getPosInselY(), insel.getPosInselX(), insel.getPosInselY(), false);
                        brueckeNeu.setzeBruecke(brueckeNeu, listGezeichneteBruecken);
                        System.out.println("InselW: " +insel.getPosInselX() +", " +insel.getPosInselY() +" und " +nextInsel.getPosInselX() +", " +nextInsel.getPosInselY());
                        System.out.println("BrückeW: " +brueckeNeu.getStartInselx() +", " +brueckeNeu.getStartInsely() +" und " +brueckeNeu.getEndInselx() +", " +brueckeNeu.getEndInsely());
                    }
                    ////// was machen  


                }
                if (SwingUtilities.isRightMouseButton(e))
                {



                }
                // zeichneBruecke(startpunkt, endpunkt);
                endX=nextInsel.getPosInselX();
                endY=nextInsel.getPosInselY();
                mittelpunktX=insel.getPosInselX()*ABSTAND  + DURCHMESSER/2;
                mittelpunktY= insel.getPosInselY()*ABSTAND  + DURCHMESSER/2;
                //brueckeNeu.setzeBruecke(brueckeNeu, listGezeichneteBruecken);
                System.out.println("Maus: "+ startX +", " + startY);
                System.out.println("Insel-Mittelpunkt: "+ mittelpunktX +", " + mittelpunktY);

                repaint();


            }
        });



    }

    // Raster zeichnen
    @Override
    public void paintComponent(Graphics g) {
        //super.paintComponent(g);

        g.translate(ABSTAND, ABSTAND);
        /*
       for(Insel ins:listInseln) {

            String s = String.valueOf(ins.getAnzBruecken());
            //drawCenteredString(s, spielfeld[ins.getPosInselX()][ins.getPosInselY()]+ ABSTAND*ins.getPosInselX(), spielfeld[ins.getPosInselX()][ins.getPosInselY()]+ABSTAND*ins.getPosInselY(), g);
            g.drawString(s, spielfeld[ins.getPosInselX()][ins.getPosInselY()]+ Generator.ABSTAND*ins.getPosInselX(), spielfeld[ins.getPosInselX()][ins.getPosInselY()]+Generator.ABSTAND*ins.getPosInselY());
            g.drawOval(spielfeld[ins.getPosInselX()][ins.getPosInselY()]+ Generator.ABSTAND*ins.getPosInselX(), spielfeld[ins.getPosInselX()][ins.getPosInselY()]+Generator.ABSTAND*ins.getPosInselY(), Generator.ABSTAND/2, Generator.ABSTAND/2);

        } */
        zeichneInsel(g);
        if(listGezeichneteBruecken.size()>0) {
            zeichneBruecke(g);
        }
        //setzeBruecke

    }

    public void drawCenteredString(String s, int w, int h, Graphics g) {
        FontMetrics fm = g.getFontMetrics();
        int x = (w - fm.stringWidth(s)) / 2;
        int y = (fm.getAscent() + (h - (fm.getAscent() + fm.getDescent())) / 2);
        g.drawString(s, x, y);
    }



    private void zeichneInsel(Graphics g) {
        //Graphics g = this.getGraphics();
        for(Insel ins:listInseln) {

            String s = String.valueOf(ins.getAnzBruecken());
            //drawCenteredString(s, spielfeld[ins.getPosInselX()][ins.getPosInselY()]+ ABSTAND*ins.getPosInselX(), spielfeld[ins.getPosInselX()][ins.getPosInselY()]+ABSTAND*ins.getPosInselY(), g);
            g.drawString(s, spielfeld[ins.getPosInselX()][ins.getPosInselY()]+ ABSTAND*ins.getPosInselX(), spielfeld[ins.getPosInselX()][ins.getPosInselY()]+ABSTAND*ins.getPosInselY());
            g.drawOval(spielfeld[ins.getPosInselX()][ins.getPosInselY()]+ ABSTAND*ins.getPosInselX(), spielfeld[ins.getPosInselX()][ins.getPosInselY()]+ABSTAND*ins.getPosInselY(), DURCHMESSER/2, DURCHMESSER/2);

            System.out.println((ABSTAND*ins.getPosInselX()+ DURCHMESSER/2) + ", " +(ABSTAND*ins.getPosInselY()+DURCHMESSER/2));
        }

    }


    private void zeichneBruecke(Graphics g) {


        berechneStandortBruecke(endX, endY);
        System.out.println("Brücke: " +startX +", "+startY +" und " +endX +", " +endY);
        //System.out.println("B: " +brueckeNeu.getStartInselx() + ", "+brueckeNeu.getStartInsely() +" und " +brueckeNeu.getEndInselx() +", " +brueckeNeu.getEndInsely());

        g.setColor(Color.PINK);
        g.drawLine(startX, startY, endX, endY);
        //for(Bruecke br:listGezeichneteBruecken)
    }


    // Spielfeld initialisieren
    private void spielfeldInitialisieren() {
        // Arrays.fill(spielfeld, 0);
        for (int i = 0; i < Generator.breite; i++) {
            for (int y = 0; y < Generator.hoehe; y++) {
                spielfeld[i][y] = 0;
            }
        }
    }


    void berechneStandortBruecke(int x2, int y2) {

        endX = x2 * ABSTAND  +DURCHMESSER/2;
        endY = y2 * ABSTAND  + DURCHMESSER/2;
    }


    /**
     *  Prüft, ob der Mausklick der Klicksektor "Nord" trifft und gibt die gefundene Insel an.
     *  
     * @param mausX X-Wert der Maus beim Klicken
     * @param mausY Y-Wert der Maus beim Klicken
     * @return true, wenn Mausklick im Klicksektor Nord trifft
     */

    boolean isInsideNord(int mausX, int mausY) {
        boolean isInside=false;
        //mittelpunktX

        //for(Insel i: listInseln) {
        for(int i=0; i<listInseln.size(); i++) {
            if((listInseln.get(i).getPosInselX()*ABSTAND  + DURCHMESSER/2) - d < mausX && mausX < (listInseln.get(i).getPosInselX()*ABSTAND  + DURCHMESSER/2) + d
                    && (listInseln.get(i).getPosInselY()*ABSTAND + DURCHMESSER/2) > mausY && mausY > (listInseln.get(i).getPosInselY()*ABSTAND + DURCHMESSER/2) - d
                    && Math.abs(mausX-(listInseln.get(i).getPosInselX()*ABSTAND + DURCHMESSER/2)) < Math.abs(mausY - (listInseln.get(i).getPosInselY()*ABSTAND + DURCHMESSER/2))) {
                insel=listInseln.get(i);
                return isInside=true;
            }
        }

        return isInside;
    }


    /**
     *  Prüft, ob der Mausklick der Klicksektor "Ost" trifft und gibt die gefundene Insel an.
     *  
     * @param mausX X-Wert der Maus beim Klicken
     * @param mausY Y-Wert der Maus beim Klicken
     * @return true, wenn Mausklick im Klicksektor Ost trifft
     */

    boolean isInsideOst(int mausX, int mausY) {
        boolean isInside=false;

        //for(Insel i: listInseln) {
        for(int i=0; i<listInseln.size(); i++) {
            if((listInseln.get(i).getPosInselX()*ABSTAND + DURCHMESSER/2) < mausX && mausX < (listInseln.get(i).getPosInselX()*ABSTAND + DURCHMESSER/2) + d
                    && (listInseln.get(i).getPosInselY()*ABSTAND + DURCHMESSER/2) -d < mausY && mausY < (listInseln.get(i).getPosInselY()*ABSTAND + DURCHMESSER/2) + d
                    && Math.abs(mausY - (listInseln.get(i).getPosInselY()*ABSTAND + DURCHMESSER/2)) < Math.abs(mausX - (listInseln.get(i).getPosInselX()*ABSTAND + DURCHMESSER/2))) {
                insel=listInseln.get(i);
                return isInside=true;
            }
        }
        return isInside;
    }


    /**
     *  Prüft, ob der Mausklick der Klicksektor "Süd" trifft und gibt die gefundene Insel an.
     *  
     * @param mausX X-Wert der Maus beim Klicken
     * @param mausY Y-Wert der Maus beim Klicken
     * @return true, wenn Mausklick im Klicksektor Süd trifft
     */


    boolean isInsideSued(int mausX, int mausY) {
        boolean isInside=false;

        //for(Insel i:listInseln) {
        for(int i=0; i<listInseln.size(); i++) {
            if((listInseln.get(i).getPosInselX()*ABSTAND + DURCHMESSER/2) < mausX && mausX < (listInseln.get(i).getPosInselX()*ABSTAND + DURCHMESSER/2) +d
                    && (listInseln.get(i).getPosInselY()*ABSTAND + DURCHMESSER/2) -d < mausY && mausY < (listInseln.get(i).getPosInselY()*ABSTAND + DURCHMESSER/2) +d
                    && Math.abs(mausY - (listInseln.get(i).getPosInselY()*ABSTAND + DURCHMESSER/2)) > Math.abs(mausX - (listInseln.get(i).getPosInselX()*ABSTAND + DURCHMESSER/2))) {
                insel=listInseln.get(i);
                return isInside=true;
            }
        }
        return isInside;
    }


    /**
     *  Prüft, ob der Mausklick der Klicksektor "West" trifft und gibt die gefundene Insel an.
     *  
     * @param mausX X-Wert der Maus beim Klicken
     * @param mausY Y-Wert der Maus beim Klicken
     * @return true, wenn Mausklick im Klicksektor West trifft
     */

    boolean isInsideWest(int mausX, int mausY) {
        boolean isInside=false;

        //for(Insel i:listInseln) {
        for(int i=0; i<listInseln.size(); i++) {
            if((listInseln.get(i).getPosInselX()*ABSTAND + DURCHMESSER/2) > mausX && mausX > (listInseln.get(i).getPosInselX()*ABSTAND + DURCHMESSER/2) -d
                    && (listInseln.get(i).getPosInselY()*ABSTAND + DURCHMESSER/2) -d < mausY && mausY < (listInseln.get(i).getPosInselY()*ABSTAND + DURCHMESSER/2) +d
                    && Math.abs(mausX -(listInseln.get(i).getPosInselX())*ABSTAND + DURCHMESSER/2) > Math.abs(mausY -(listInseln.get(i).getPosInselY()*ABSTAND + DURCHMESSER/2))) {
                insel=listInseln.get(i);
                return isInside=true;
            }
        }
        return isInside;
    }


    public int[][] getSpielfeld() {
        return spielfeld;
    }

    public void setSpielfeld(int[][] spielfeld) {
        this.spielfeld = spielfeld;
    }

    public ArrayList<Insel> getListInseln() {
        return listInseln;
    }

    public void setListInseln(ArrayList<Insel> listInseln) {
        this.listInseln = listInseln;
    }

    public ArrayList<Bruecke> getListBruecken() {
        return listBruecken;
    }

    public void setListBruecken(ArrayList<Bruecke> listBruecken) {
        this.listBruecken = listBruecken;
    }

}

 

[Josie]

und noch die Klasse Insel in zwei Teilen:

Teil A:

package root;

import rechner.*;

import java.util.*;

public class Insel implements Comparable<Insel>{

    private int posInselX;
    private int posInselY;
    private int id;
    private int anzahlBruecken;
    private int anzahlBrueckenNeu;
    private int yNord;
    private int xOst;
    private int ySued;
    private int xWest;
    private boolean doppelt;

    int maxNord;
    int maxOst;
    int maxSued;
    int maxWest;

    private boolean brueckeZwischenZweiBestInselnNord = false;
    private boolean brueckeZwischenZweiBestInselnOst = false;
    private boolean brueckeZwischenZweiBestInselnSued = false;
    private boolean brueckeZwischenZweiBestInselnWest = false;
    Insel nextInselNord;
    Insel nextInselOst;
    Insel nextInselSued;
    Insel nextInselWest;
    private boolean isNotDoppelt=false;
    private boolean keineDirektenNachbarn=false;
    private boolean stopp = false;
    private boolean brueckeAufLinieNord=false;
    private boolean brueckeAufLinieOst=false;
    private boolean brueckeAufLinieSued=false;
    private boolean brueckeAufLinieWest=false;

    private int abstandNextInselOKNord;
    private int abstandNextInselOKOst;
    private int abstandNextInselOKSued;
    private int abstandNextInselOKWest;
    private int abstandNextBrueckeNord;
    private int abstandNextBrueckeOst;
    private int abstandNextBrueckeSued;
    private int abstandNextBrueckeWest;
    private boolean brueckeNichtKreuzNord=true;
    private boolean brueckeNichtKreuzOst=true;
    private boolean brueckeNichtKreuzSued=true;
    private boolean brueckeNichtKreuzWest=true;
    private boolean posInselAmRandNord=false;
    private boolean posInselAmRandOst=false;
    private boolean posInselAmRandSued=false;
    private boolean posInselAmRandWest=false;

    private boolean loesbarN = true;
    private boolean loesbarO = true;
    private boolean loesbarS  = true;
    private boolean loesbarW  = true;


    // int[][] bestSpielfeld;

    // Listen
    private ArrayList<Insel> bestInselListe;
    private ArrayList<Bruecke> bestBrueckeListe = Generator.getListBruecken();
    private ArrayList<Insel> waehlbareInselnListe = Generator.getwaehlbareInselnListe();
    private ArrayList<Insel> nichtWaehlbareInselnListe = Generator.getNichtWaehlbareInselnListe();

    public Insel(int neuX, int neuY, ArrayList<Insel> bestInselListe, int id,
            int anzBruecken, boolean loesbarN, boolean loesbarO,  boolean loesbarS,  boolean loesbarW) {
        this.posInselX = neuX;
        this.posInselY = neuY;
        this.id = id;
        this.anzahlBruecken = anzBruecken;
        this.bestInselListe = bestInselListe;
        this.loesbarN =  loesbarN;
        this.loesbarO =  loesbarO;
        this.loesbarS =  loesbarS;
        this.loesbarW = loesbarW;

    }


    /**
     *
     * in dieser Methode werden die weiteren (ab 2.) Inseln und Brücken berechnet, geprüft und in Listen gesetzt. Wenn eine
     * Insel nicht mehr verwendet werden kann, wird sie in die Liste "nichtWaehlbareInselnListe" gesetzt. So wird eine unendliche
     * Schleife vermieden, wenn keine Inseln gesetzt werden können, aber noch müssen.
     *
     * @param insel
     */
    public void weitereInselnBestimmen(Insel insel) {

        Insel inselNeu = null;
        Bruecke brueckeNeu=null;

        // eine best. Insel auswählen, von der weiter berechnet wird
        Insel bestInsel = getRandomItem(waehlbareInselnListe, bestInselListe); //Insel aus wählbaren Inselliste zufällig auswählen
       
       

        System.out.println("PosX: " + bestInsel.getPosInselX());
        System.out.println("PosY: " + bestInsel.getPosInselY());
        //alle Richtungen kontrollieren, ob nicht schon belegt mit Brücke
        brueckeAufLinieNord=pruefeMitBrueckeVerbundenNord(bestInsel, bestInselListe, bestBrueckeListe); // true, wenn mit Brücke verbunden
        brueckeAufLinieOst=pruefeMitBrueckeVerbundenOst(bestInsel, bestInselListe, bestBrueckeListe); // true, wenn mit Brücke verbunden
        brueckeAufLinieSued=pruefeMitBrueckeVerbundenSued(bestInsel, bestInselListe, bestBrueckeListe); // true, wenn mit Brücke verbunden
        brueckeAufLinieWest=pruefeMitBrueckeVerbundenWest(bestInsel, bestInselListe, bestBrueckeListe); // true, wenn mit Brücke verbunden
        System.out.println("brueckeAufLinieNord (Brücke im Norden) " + brueckeAufLinieNord);
        System.out.println("brueckeAufLinieOst (Brücke im Osten) " + brueckeAufLinieOst);
        System.out.println("brueckeAufLinieSued (Brücke im Süden) " + brueckeAufLinieSued);
        System.out.println("brueckeAufLinieWest (Brücke im Westen) " + brueckeAufLinieWest);


        int xbest = bestInsel.getPosInselX();
        int ybest = bestInsel.getPosInselY();
        //int bruecken;






        // max. möglicher Abstand bis Rand
        maxNord = ybest;
        maxOst = (Generator.breite - 1) - xbest;
        maxSued = (Generator.hoehe - 1) - ybest;
        maxWest = xbest;

        pruefeInselWiederverwendenBest( bestInsel, bestInselListe, waehlbareInselnListe, nichtWaehlbareInselnListe);
       
       
        int countBrueckenBest = bestInsel.anzahlBruecken;
        int countBrueckenNext;
        nextInselNord= naechsteInselNord(bestInsel, bestInselListe); //Abstand bestehenden Insel bis nächste Insel Nord, sonst max Abstand bis Rand
        if(nextInselNord !=null) System.out.println("nextInselNord (Nächste Insel im Norden) " + nextInselNord.getPosInselX() +", " +nextInselNord.getPosInselY());
        nextInselOst= naechsteInselOst(bestInsel, bestInselListe); //Abstand bestehenden Insel bis nächste Insel Ost, sonst max Abstand bis Rand
        if(nextInselOst !=null) System.out.println("nextInselOst (Nächste Insel im Osten) " + nextInselOst.getPosInselX() +", " +nextInselOst.getPosInselY());
        nextInselSued= naechsteInselSued(bestInsel, bestInselListe); //Abstand bestehenden Insel bis nächste Insel Süd, sonst max Abstand bis Rand
        if(nextInselSued !=null) System.out.println("nextInselSued (Nächste Insel im Süden) " + nextInselSued.getPosInselX() +", " +nextInselSued.getPosInselY());
        nextInselWest= naechsteInselWest(bestInsel, bestInselListe); //Abstand bestehenden Insel bis nächste Insel West, sonst max Abstand bis Rand
        if(nextInselWest !=null ) System.out.println("nextInselWest (Nächste Insel im Westen) " + nextInselWest.getPosInselX() +", " +nextInselWest.getPosInselY());
////////////////////nur zur Kontrolle, wieder entfernen!!////////
        pruefeAbstandBisNaechsteBrueckeNord(bestInsel, bestBrueckeListe);
        pruefeAbstandBisNaechsteBrueckeOst(bestInsel, bestBrueckeListe);
        pruefeAbstandBisNaechsteBrueckeSued(bestInsel, bestBrueckeListe);
        pruefeAbstandBisNaechsteBrueckeWest(bestInsel, bestBrueckeListe);


        // der Abstand bis nächste Insel kontrollieren
        if(brueckeAufLinieNord==false) { // es sind Brücken im Norden vorhanden

            if(nextInselNord == null) {
                countBrueckenNext = 0;
            }
            else {
                countBrueckenNext = nextInselNord.anzahlBruecken;

                //Abstand bestehenden Insel bis nächste Insel Nord, sonst max Abstand bis Rand
                abstandNextInselOKNord = pruefeAbstandBisNaechsteInselNord(bestInsel, nextInselNord, bestInselListe); //Abstand bis nächster Insel

                //pruefeKreuzungBrueckenNord(nextInselNord, bestInsel, bestBrueckeListe);

                //Abstand bestehenden Insel bis nächsten Brücke Nord, sonst max Abstand bis Rand
                abstandNextBrueckeNord=pruefeAbstandBisNaechsteBrueckeNord(bestInsel, bestBrueckeListe);

            } // wenn keine Brücke zwischen den best Insel liegt
            if(abstandNextBrueckeNord>abstandNextInselOKNord) {
                System.out.println("Keine Brücke zwischen best Inseln möglich");

                // wenn beide best Insel verbindbar sind, verbinde sie
                if(abstandNextInselOKNord>=1 && brueckeNichtKreuzNord && nextInselNord!=null && countBrueckenBest <=6 && countBrueckenNext <=6) {

                    anzahlBrueckenNeu = getRandomBruecke();
                    if(anzahlBrueckenNeu==2)
                        doppelt=true;
                    else doppelt=false;
                    brueckeNeu = new Bruecke(nextInselNord.getId(), bestInsel.getId(), bestBrueckeListe, nextInselNord.getPosInselX(), nextInselNord.getPosInselY(), bestInsel.getPosInselX(), bestInsel.getPosInselY(), doppelt );
                    brueckeNeu.setzeBruecke(brueckeNeu, bestBrueckeListe);
                    //int countBrueckenBest = bestInsel.getAnzBruecken()+anzahlBrueckenNeu;
                    countBrueckenNext = nextInselNord.getAnzBruecken()+anzahlBrueckenNeu;
                    countBrueckenBest = bestInsel.getAnzBruecken()+anzahlBrueckenNeu;
                    bestInsel.setAnzBrueckenNeu(countBrueckenBest);
                    nextInselNord.setAnzBrueckenNeu(countBrueckenNext);
                    brueckeZwischenZweiBestInselnNord = true;
                    System.out.println("verbinde Brücke mit zwei best Inseln Nord");
                    System.out.println("Brücke neu start/end-ID: " +nextInselNord.getId() +bestInsel.getId());
                    System.out.println("Anz Brücken best: " +countBrueckenBest + ", anz Brücken next " + countBrueckenNext);
                    pruefeInselWiederverwendenNeu(nextInselNord, bestInselListe, waehlbareInselnListe, nichtWaehlbareInselnListe);
                    pruefeInselWiederverwendenBest( bestInsel, bestInselListe, waehlbareInselnListe, nichtWaehlbareInselnListe);
                }

            }
        }
        if(brueckeAufLinieOst==false) {

            if(nextInselOst == null) {
                countBrueckenNext = 0;
            }
            else {
                countBrueckenNext = nextInselOst.anzahlBruecken;

                //Abstand bestehenden Insel bis nächste Insel Ost, sonst max Abstand bis Rand
                abstandNextInselOKOst = pruefeAbstandBisNaechsteInselOst(bestInsel, nextInselOst, bestInselListe);
                //pruefeKreuzungBrueckenOst(nextInselOst, bestInsel, bestBrueckeListe);

                //Abstand bestehenden Insel bis nächsten Brücke Ost, sonst max Abstand bis Rand
                abstandNextBrueckeOst=pruefeAbstandBisNaechsteBrueckeOst(bestInsel, bestBrueckeListe);

            } // wenn keine Brücke zwischen den best Insel liegt
            if(abstandNextBrueckeOst>abstandNextInselOKOst) {
                System.out.println("Keine Brücke zwischen best Inseln möglich");

                // wenn beide best Insel verbindbar sind, verbinde sie
                if(abstandNextInselOKOst>=1 && brueckeNichtKreuzOst && nextInselOst!=null && countBrueckenBest <=6 && countBrueckenNext <=6) {

                    anzahlBrueckenNeu = getRandomBruecke();
                    if(anzahlBrueckenNeu==2)
                        doppelt=true;
                    else doppelt=false;
                    brueckeNeu = new Bruecke(bestInsel.getId(), nextInselOst.getId(), bestBrueckeListe, bestInsel.getPosInselX(), bestInsel.getPosInselY(), nextInselOst.getPosInselX(), nextInselOst.getPosInselY() , doppelt);
                    brueckeNeu.setzeBruecke(brueckeNeu, bestBrueckeListe);
                    countBrueckenBest = bestInsel.getAnzBruecken()+anzahlBrueckenNeu;
                    countBrueckenNext = nextInselOst.getAnzBruecken()+anzahlBrueckenNeu;
                    bestInsel.setAnzBrueckenNeu(countBrueckenBest);
                    nextInselOst.setAnzBrueckenNeu(countBrueckenNext);
                    brueckeZwischenZweiBestInselnOst = true;
                    System.out.println("verbinde Brücke mit zwei best Inseln Ost");
                    System.out.println("Brücke neu start/end-ID: " +bestInsel.getId() + ", " +nextInselOst.getId() );
                    System.out.println("Anz Brücken best: " +countBrueckenBest + ", anz Brücken next " + countBrueckenNext);
                    pruefeInselWiederverwendenNeu(nextInselOst, bestInselListe, waehlbareInselnListe, nichtWaehlbareInselnListe);
                    pruefeInselWiederverwendenBest(bestInsel, bestInselListe, waehlbareInselnListe, nichtWaehlbareInselnListe);
                }
            }
        }
        if(brueckeAufLinieSued==false) {

            if(nextInselSued == null) {
                countBrueckenNext = 0;
            }
            else {
                countBrueckenNext = nextInselSued.anzahlBruecken;

                //Abstand bestehenden Insel bis nächste Insel Süd, sonst max Abstand bis Rand
                abstandNextInselOKSued = pruefeAbstandBisNaechsteInselSued(bestInsel, nextInselSued, bestInselListe);
                //pruefeKreuzungBrueckenSued(nextInselSued, bestInsel, bestBrueckeListe);

                //Abstand bestehenden Insel bis nächsten Brücke Süd, sonst max Abstand bis Rand
                abstandNextBrueckeSued=pruefeAbstandBisNaechsteBrueckeSued(bestInsel, bestBrueckeListe);

            } // wenn keine Brücke zwischen den best Insel liegt
            if(abstandNextBrueckeSued>abstandNextInselOKSued) {
                System.out.println("Keine Brücke zwischen best Inseln möglich");

                // wenn beide best Insel verbindbar sind, verbinde sie
                if(abstandNextInselOKSued>=1 && brueckeNichtKreuzSued && nextInselSued!=null && countBrueckenBest <=6 && countBrueckenNext <=6) {

                    anzahlBrueckenNeu = getRandomBruecke();
                    if(anzahlBrueckenNeu==2)
                        doppelt=true;
                    else doppelt=false;
                    brueckeNeu = new Bruecke(bestInsel.getId(), nextInselSued.getId(), bestBrueckeListe, bestInsel.getPosInselX(), bestInsel.getPosInselY(), nextInselSued.getPosInselX(), nextInselSued.getPosInselY(), doppelt );
                    brueckeNeu.setzeBruecke(brueckeNeu, bestBrueckeListe);
                    countBrueckenBest = bestInsel.getAnzBruecken()+anzahlBrueckenNeu;
                    countBrueckenNext = nextInselSued.getAnzBruecken()+anzahlBrueckenNeu;
                    bestInsel.setAnzBrueckenNeu(countBrueckenBest);
                    nextInselSued.setAnzBrueckenNeu(countBrueckenNext);
                    brueckeZwischenZweiBestInselnSued = true;
                    System.out.println("verbinde Brücke mit zwei best Inseln Süd");
                    System.out.println("Brücke neu start/end-ID: " +bestInsel.getId() +", " + nextInselSued.getId());
                    System.out.println("Anz Brücken best: " +countBrueckenBest + ", anz Brücken next " + countBrueckenNext);
                    pruefeInselWiederverwendenNeu(nextInselSued, bestInselListe, waehlbareInselnListe, nichtWaehlbareInselnListe);
                    pruefeInselWiederverwendenBest(bestInsel, bestInselListe, waehlbareInselnListe, nichtWaehlbareInselnListe);
                }
            }
        }
        // wenn beide best Insel verbindbar sind, verbinde sie
        if(brueckeAufLinieWest==false) {

            if(nextInselWest == null) {
                countBrueckenNext=0;
            }
            else {
                countBrueckenNext = nextInselWest.anzahlBruecken;

                //Abstand bestehenden Insel bis nächste Insel West, sonst max Abstand bis Rand
                abstandNextInselOKWest = pruefeAbstandBisNaechsteInselWest(bestInsel, nextInselWest, bestInselListe);
                //pruefeKreuzungBrueckenWest(nextInselWest, bestInsel, bestBrueckeListe);

                //Abstand bestehenden Insel bis nächsten Brücke Nord, sonst max Abstand bis Rand
                abstandNextBrueckeWest=pruefeAbstandBisNaechsteBrueckeWest(bestInsel, bestBrueckeListe);

            } // wenn keine Brücke zwischen den best Insel liegt
            if(abstandNextBrueckeWest>abstandNextInselOKWest) {
                System.out.println("Keine Brücke zwischen best Inseln möglich");

                if(abstandNextInselOKWest>=1 && brueckeNichtKreuzWest && nextInselWest!=null && countBrueckenBest <=6 && countBrueckenNext <=6) {

                    anzahlBrueckenNeu = getRandomBruecke();
                    if(anzahlBrueckenNeu==2)
                        doppelt=true;
                    else doppelt=false;
                    brueckeNeu = new Bruecke(nextInselWest.getId(), bestInsel.getId(), bestBrueckeListe, nextInselWest.getPosInselX(), nextInselWest.getPosInselY(), bestInsel.getPosInselX(), bestInsel.getPosInselY(), doppelt );
                    brueckeNeu.setzeBruecke(brueckeNeu, bestBrueckeListe);
                    countBrueckenBest = bestInsel.getAnzBruecken()+anzahlBrueckenNeu;
                    countBrueckenNext = nextInselWest.getAnzBruecken()+anzahlBrueckenNeu;
                    bestInsel.setAnzBrueckenNeu(countBrueckenBest);
                    nextInselWest.setAnzBrueckenNeu(countBrueckenNext);
                    brueckeZwischenZweiBestInselnWest = true;
                    System.out.println("verbinde Brücke mit zwei best Inseln West");
                    System.out.println("Brücke neu start/end-ID: " +nextInselWest.getId() +bestInsel.getId());
                    System.out.println("Anz Brücken best: " +countBrueckenBest + ", anz Brücken next " + countBrueckenNext);
                    pruefeInselWiederverwendenNeu(nextInselWest, bestInselListe, waehlbareInselnListe, nichtWaehlbareInselnListe);
                    pruefeInselWiederverwendenBest( bestInsel, bestInselListe, waehlbareInselnListe, nichtWaehlbareInselnListe);
                }
            }
        }
       

        // Der Rand kontrollieren
        pruefeInselAmRandNord(bestInsel, bestInselListe);
        pruefeInselAmRandOst(bestInsel, bestInselListe);
        pruefeInselAmRandSued(bestInsel, bestInselListe);
        pruefeInselAmRandWest(bestInsel, bestInselListe);
        
        // int yNord = 0;
        Random r = new Random();

        ////////////////////////////////// Nord //////////////////////////////////       
        //ausgewählte Insel hat weniger als 8 Brücken
        if (countBrueckenBest < 7 ) {

            //Anzahl Gesamtinseln sind noch nicht erreicht && wählbareInselListe ist nicht leer
            if(Generator.countAnzInsel<Generator.maximum && waehlbareInselnListe.size() > 0) {
                pruefeInselWiederverwendenBest( bestInsel, bestInselListe, waehlbareInselnListe, nichtWaehlbareInselnListe);
               
                if ((abstandNextInselOKNord >= 3 || (maxNord >1 && nextInselNord == null)) && brueckeAufLinieNord==false && posInselAmRandNord==false && bestInsel.isLoesbarN()==true) {
                    System.out.println("Nord");

                    if(countBrueckenBest<=6 && brueckeZwischenZweiBestInselnNord == false) {
                        System.out.println("reinN");
                        while((isNotDoppelt==false || keineDirektenNachbarn==false) && stopp==false){
                            System.out.println("in WhileSchlaufe");
                           
                            // zufälliger Abstand der neuen Insel wählen
                            if(nextInselNord == null) {
                                yNord = r.nextInt((ybest - 2) + 1);
                            }
                            else {
                                yNord = r.nextInt((ybest-2) -(ybest-abstandNextInselOKNord + 1) + 1) + (ybest- abstandNextInselOKNord + 1);
                            }
                            //kreuzenBrücken?

                            anzahlBrueckenNeu = getRandomBruecke(); // wählt zufällig Anzahl Brücke zwischen 1 und 2

                            inselNeu = new Insel(xbest, yNord, bestInselListe,
                                    Generator.countAnzInsel, anzahlBrueckenNeu, true, true, true, true);
                            if(inselNeu == null) {
                                System.out.println("inselNeu == null");
                                continue;   
                            }
                            isNotDoppelt=pruefePositionBereitsVorhanden(inselNeu, bestInselListe); // wenn nicht, setze Insel
                            keineDirektenNachbarn=pruefeAufDirekteNachbarn(inselNeu);
                            System.out.println( "pos nichtvorhandenNord: " +isNotDoppelt );
                            System.out.println( "keineDirekteNachbarnNord: " +keineDirektenNachbarn );

                            if(isNotDoppelt==false || keineDirektenNachbarn==false)
                            {
                                //Prüfen, ob Brücke mit einem Abstand neben best Insel liegt oder direkt neben neuer Insel mit nur einer Setzposition
                                if(pruefePositionNord(bestInsel, inselNeu, bestInselListe,bestBrueckeListe)==true) {
                                    //nichtWaehlbareInselnListe.add(bestInsel);
                                    //waehlbareInselnListe.remove(bestInsel);
                                    stopp=true;
                                    bestInsel.setLoesbarN(false);
                                    //System.out.println( inselNeu.getId() +" in nichtWaehlbareInselnListe hinzugefügt" );
                                    //System.out.println( inselNeu.getId() +" in waehlbareInselnListe gelöscht");

                                }
                                inselNeu = null;
                                System.gc();
                                //Generator.countAnzInsel--;
                                System.out.println( "pos suchen wiederholen");

                            }
                            System.out.println( "pos nichtvorhandenNord: " +isNotDoppelt );

                        }

                        if(stopp==false && inselNeu != null) {

                            //pruefeInselWiederverwendenBest(inselNeu, bestInsel, bestInselListe, waehlbareInselnListe, nichtWaehlbareInselnListe);
                            brueckeNichtKreuzNord=pruefeKreuzungBrueckenNord(inselNeu, bestInsel, bestBrueckeListe); //false, wenn Brücke gekreuzt wird: Insel wird gelöscht!





                            //if(countBruecken<=6 && brueckeNichtKreuzNord) {
                            if(brueckeNichtKreuzNord) {
                                inselNeu.setzeInsel(inselNeu, bestInselListe, waehlbareInselnListe);
                                bestInsel.setLoesbarN(false);
                                Generator.countAnzInsel++;
                                if(anzahlBrueckenNeu==2)
                                    doppelt=true;
                                else doppelt=false;
                                brueckeNeu = new Bruecke(inselNeu.getId(), bestInsel.getId(), bestBrueckeListe, inselNeu.getPosInselX(), inselNeu.getPosInselY(), bestInsel.getPosInselX(), bestInsel.getPosInselY(), doppelt );
                                brueckeNeu.setzeBruecke(brueckeNeu, bestBrueckeListe);
                                countBrueckenBest = countBrueckenBest+anzahlBrueckenNeu;
                                bestInsel.setAnzBrueckenNeu(countBrueckenBest);
                                //pruefeInselWiederverwendenBest(inselNeu, bestInsel, bestInselListe, waehlbareInselnListe, nichtWaehlbareInselnListe);
                                pruefeInselWiederverwendenNeu(inselNeu,  bestInselListe, waehlbareInselnListe, nichtWaehlbareInselnListe);
                                //System.out.println("Insel setzen: " + bestInsel.id);

                                System.out.println( "Koordinate Brücke: " +"start/end-ID: " + inselNeu.getId()  +", "+bestInsel.getId());
                                System.out.println( "Anzahl Brücken best Brücke: " +countBrueckenBest);
                                System.out.println( "Neue InselNord: " +inselNeu.getPosInselX() +", " +inselNeu.getPosInselY());
                                System.out.println( "Neue Insel lösbar: " +inselNeu.isLoesbarN() +", " +inselNeu.isLoesbarO()+", " +inselNeu.isLoesbarS()+", " +inselNeu.isLoesbarW());
                                System.out.println( "Anzahl total Insel: " +Generator.countAnzInsel);
                            }
                            isNotDoppelt=false;
                            keineDirektenNachbarn=false;
                            stopp=false;
                            pruefeInselWiederverwendenBest(bestInsel, bestInselListe, waehlbareInselnListe, nichtWaehlbareInselnListe);
                            System.out.println( "BestInsel lösbar: " +bestInsel.isLoesbarN() +", " +bestInsel.isLoesbarO()+", " +bestInsel.isLoesbarS()+", " +bestInsel.isLoesbarW());
                        }
                    } else bestInsel.setLoesbarN(false);
                }



                ////////////////////////////////// Ost //////////////////////////////////

                //Anzahl Gesamtinseln sind noch nicht erreicht && wählbareInselListe ist nicht leer
                if(Generator.countAnzInsel<Generator.maximum && waehlbareInselnListe.size() > 0) {
                   
                    pruefeInselWiederverwendenBest( bestInsel, bestInselListe, waehlbareInselnListe, nichtWaehlbareInselnListe);


                    if ((abstandNextInselOKOst >= 3 || (maxOst >1 && nextInselOst == null))  && brueckeAufLinieOst==false && posInselAmRandOst==false && bestInsel.isLoesbarO()==true) {
                        System.out.println("Ost");

                        if(countBrueckenBest<=6 && brueckeZwischenZweiBestInselnOst == false) {
                            System.out.println("reinO");
                            while((isNotDoppelt==false || keineDirektenNachbarn==false) && stopp==false){
                                System.out.println("in WhileSchlaufe");

                                if( nextInselOst == null) {
                                    xOst = r.nextInt(((Generator.breite - 1) - (xbest + 2) + 1))+ (xbest + 2);
                                }
                                else {
                                    xOst = r.nextInt((xbest+abstandNextInselOKOst -1) -(xbest+2) +1) + xbest+2;
                                }


                                anzahlBrueckenNeu = getRandomBruecke(); // wählt zufällig
                                // Anzahl Brücke
                                // zwischen 1 und 2

                                inselNeu = new Insel(xOst, ybest, bestInselListe,
                                        Generator.countAnzInsel, anzahlBrueckenNeu, true, true, true, true);
                                if(inselNeu == null) {
                                    System.out.println("inselNeu == null");
                                    continue;   
                                }
                                isNotDoppelt=pruefePositionBereitsVorhanden(inselNeu, bestInselListe);
                                keineDirektenNachbarn= pruefeAufDirekteNachbarn(inselNeu);
                                System.out.println( "pos nichtvorhandenOst: " +isNotDoppelt );
                                System.out.println( "keineDirekteNachbarnOst: " +keineDirektenNachbarn );

                                if(isNotDoppelt==false || keineDirektenNachbarn==false)
                                {
                                    //Prüfen, ob Brücke mit einem Abstand neben best Insel liegt oder direkt neben neuer Insel mit nur einer Setzposition
                                    if(pruefePositionOst(bestInsel, inselNeu, bestInselListe,bestBrueckeListe)==true) {
                                        //nichtWaehlbareInselnListe.add(bestInsel);
                                        //waehlbareInselnListe.remove(bestInsel);
                                        stopp=true;
                                        bestInsel.setLoesbarO(false);
                                      
                                    }
                                    inselNeu = null;
                                    System.gc();
                                    System.out.println( "pos suchen wiederholen");

                                }
                                System.out.println( "pos nichtvorhandenOst: " +isNotDoppelt );

                            }

                            if(stopp==false && inselNeu != null) {

                                //pruefeInselWiederverwendenBest(inselNeu, bestInsel, bestInselListe, waehlbareInselnListe, nichtWaehlbareInselnListe);
                                brueckeNichtKreuzOst=pruefeKreuzungBrueckenOst(inselNeu, bestInsel, bestBrueckeListe);  //false, wenn Brücke gekreuzt wird: Insel wird gelöscht!




                                if(brueckeNichtKreuzOst) {
                                    inselNeu.setzeInsel(inselNeu, bestInselListe, waehlbareInselnListe);
                                    bestInsel.setLoesbarO(false);
                                    Generator.countAnzInsel++;
                                    if(anzahlBrueckenNeu==2)
                                        doppelt=true;
                                    else doppelt=false;
                                    brueckeNeu = new Bruecke(bestInsel.getId(), inselNeu.getId(), bestBrueckeListe, bestInsel.getPosInselX(), bestInsel.getPosInselY(), inselNeu.getPosInselX(), inselNeu.getPosInselY(), doppelt );
                                    brueckeNeu.setzeBruecke(brueckeNeu, bestBrueckeListe);
                                    countBrueckenBest = countBrueckenBest+anzahlBrueckenNeu;
                                    bestInsel.setAnzBrueckenNeu(countBrueckenBest);
                                    //pruefeInselWiederverwendenBest(inselNeu, bestInsel, bestInselListe, waehlbareInselnListe, nichtWaehlbareInselnListe);
                                    pruefeInselWiederverwendenNeu(inselNeu, bestInselListe, waehlbareInselnListe, nichtWaehlbareInselnListe);

                                    System.out.println( "Koordinate Brücke: " +"start/end-ID: " +  bestInsel.getId() +", "+inselNeu.getId());
                                    System.out.println( "Anzahl Brücken best Brücke: " +countBrueckenBest);
                                    System.out.println( "Neue InselOst: " +inselNeu.getPosInselX() +", " +inselNeu.getPosInselY());
                                    System.out.println( "Neue Insel lösbar: " +inselNeu.isLoesbarN() +", " +inselNeu.isLoesbarO()+", " +inselNeu.isLoesbarS()+", " +inselNeu.isLoesbarW());
                                    System.out.println( "Anzahl total Insel: " +Generator.countAnzInsel);
                                }
                                isNotDoppelt=false;
                                keineDirektenNachbarn=false;
                                stopp=false;
                                pruefeInselWiederverwendenBest( bestInsel, bestInselListe, waehlbareInselnListe, nichtWaehlbareInselnListe);
                                System.out.println( "BestInsel lösbar: " +bestInsel.isLoesbarN() +", " +bestInsel.isLoesbarO()+", " +bestInsel.isLoesbarS()+", " +bestInsel.isLoesbarW());
                            }
                        } else bestInsel.setLoesbarO(false);
                    }

                    //////////////////////////////////Süd //////////////////////////////////

                    //Anzahl Gesamtinseln sind noch nicht erreicht && wählbareInselListe ist nicht leer
                    if(Generator.countAnzInsel<Generator.maximum && waehlbareInselnListe.size() > 0) {
                        // Insel kann noch Brücken 2 in Richtung Süden aufnehmen
                        pruefeInselWiederverwendenBest(bestInsel, bestInselListe, waehlbareInselnListe, nichtWaehlbareInselnListe);
                       
                        if ((abstandNextInselOKSued >= 3 || (maxSued >1 && nextInselSued == null))  && brueckeAufLinieSued== false && posInselAmRandSued== false && bestInsel.isLoesbarS()==true) {
                            System.out.println("Sued");

                            if(countBrueckenBest<=6 && brueckeZwischenZweiBestInselnSued == false) {
                                System.out.println("reinS");
                                while((isNotDoppelt==false || keineDirektenNachbarn==false) && stopp==false){
                                    System.out.println("in WhileSchlaufe");

                                   
                                    if (nextInselSued == null) {
                                        ySued = r.nextInt(((Generator.hoehe -1) - (ybest+2) + 1)) + (ybest + 2);

                                    }
                                    else {
                                        ySued = r.nextInt((ybest+abstandNextInselOKSued -1) -(ybest+2) +1) + (ybest+2);
                                    }
                                    //}
                                    //else
                                    //{
                                    //System.out.println((y + abstandNextInselOKSued -1) - (y + 2) + 1);
                                    //}
                                    anzahlBrueckenNeu = getRandomBruecke(); // wählt zufällig
                                    // Anzahl Brücke
                                    // zwischen 1 und 2

                                    inselNeu = new Insel(xbest, ySued, bestInselListe,
                                            Generator.countAnzInsel, anzahlBrueckenNeu, true, true, true, true);
                                    if(inselNeu == null) {
                                        System.out.println("inselNeu == null");
                                        continue;   
                                    }
                                    isNotDoppelt = pruefePositionBereitsVorhanden(inselNeu, bestInselListe);
                                    keineDirektenNachbarn =  pruefeAufDirekteNachbarn(inselNeu);
                                    System.out.println( "pos nichtvorhandenSüd: " +isNotDoppelt );
                                    System.out.println( "keineDirekteNachbarnSüd: " +keineDirektenNachbarn );

                                    if(isNotDoppelt==false || keineDirektenNachbarn==false)
                                    {
                                       
                                       
                                        if(pruefePositionSued(bestInsel, inselNeu, bestInselListe,bestBrueckeListe)==true) {
                                            //nichtWaehlbareInselnListe.add(bestInsel);
                                            //waehlbareInselnListe.remove(bestInsel);
                                            stopp=true;
                                            bestInsel.setLoesbarS(false);
                                            //System.out.println( inselNeu.getId() +" in nichtWaehlbareInselnListe hinzugefügt" );
                                            // System.out.println( inselNeu.getId() +" in waehlbareInselnListe gelöscht");

                                        }
                                        inselNeu = null;
                                        System.gc();
                                        System.out.println( "pos suchen wiederholen");

                                    }
                                    System.out.println( "pos nichtvorhandenSued: " +isNotDoppelt );

                                }

                                if(stopp==false && inselNeu != null) {

                                    //pruefeInselWiederverwendenBest(inselNeu, bestInsel, bestInselListe, waehlbareInselnListe, nichtWaehlbareInselnListe);
                                    brueckeNichtKreuzSued=pruefeKreuzungBrueckenSued(inselNeu, bestInsel, bestBrueckeListe);  //false, wenn Brücke gekreuzt wird: Insel wird gelöscht!

                                    // bei best Insel Anzahl Brücken anpassen
                                    //bruecken = bestInsel.anzahlBruecken + anzahlBrueckenNeu;

                                    //bestInsel.setAnzBrueckenNeu(bruecken);


                                    if(brueckeNichtKreuzSued) {
                                        inselNeu.setzeInsel(inselNeu, bestInselListe, waehlbareInselnListe);
                                        bestInsel.setLoesbarS(false);
                                        Generator.countAnzInsel++;
                                        if(anzahlBrueckenNeu==2)
                                            doppelt=true;
                                        else doppelt=false;
                                        brueckeNeu = new Bruecke(bestInsel.getId(), inselNeu.getId(), bestBrueckeListe, bestInsel.getPosInselX(), bestInsel.getPosInselY(), inselNeu.getPosInselX(), inselNeu.getPosInselY(), doppelt );
                                        brueckeNeu.setzeBruecke(brueckeNeu, bestBrueckeListe);
                                        //bestInsel.setAnzBrueckenNeu(countBrueckenBest);
                                        countBrueckenBest = countBrueckenBest+anzahlBrueckenNeu;
                                        bestInsel.setAnzBrueckenNeu(countBrueckenBest);
                                        //pruefeInselWiederverwendenBest(inselNeu, bestInsel, bestInselListe, waehlbareInselnListe, nichtWaehlbareInselnListe);
                                        pruefeInselWiederverwendenNeu(inselNeu,  bestInselListe, waehlbareInselnListe, nichtWaehlbareInselnListe);

                                        System.out.println( "Koordinate Brücke: " +"start/end-ID: " +  bestInsel.getId() +", "+inselNeu.getId());
                                        System.out.println( "Anzahl Brücken best Brücke neu: " +countBrueckenBest);
                                        System.out.println( "Neue InselSüd: " +inselNeu.getPosInselX() +", " +inselNeu.getPosInselY());
                                        System.out.println( "Neue Insel lösbar: " +inselNeu.isLoesbarN() +", " +inselNeu.isLoesbarO()+", " +inselNeu.isLoesbarS()+", " +inselNeu.isLoesbarW());
                                        System.out.println( "Anzahl total Insel: " +Generator.countAnzInsel);
                                    }
                                    isNotDoppelt=false;
                                    keineDirektenNachbarn=false;
                                    stopp=false;
                                    pruefeInselWiederverwendenBest( bestInsel, bestInselListe, waehlbareInselnListe, nichtWaehlbareInselnListe);
                                    System.out.println( "BestInsel lösbar: " +bestInsel.isLoesbarN() +", " +bestInsel.isLoesbarO()+", " +bestInsel.isLoesbarS()+", " +bestInsel.isLoesbarW());
                                }
                            } else bestInsel.setLoesbarS(false);
                        }

                        ////////////////////////////////// West //////////////////////////////////

                        //Anzahl Gesamtinseln sind noch nicht erreicht && wählbareInselListe ist nicht leer
                        if(Generator.countAnzInsel<Generator.maximum && waehlbareInselnListe.size() > 0) {

                            pruefeInselWiederverwendenBest(bestInsel, bestInselListe, waehlbareInselnListe, nichtWaehlbareInselnListe);
                           
                            if ((abstandNextInselOKWest >= 3 || (maxWest >1 && nextInselWest == null))  && brueckeAufLinieWest==false && posInselAmRandWest== false && bestInsel.isLoesbarW()==true) {
                                System.out.println("West");

                                if(countBrueckenBest<=6 && brueckeZwischenZweiBestInselnWest == false) {
                                    System.out.println("reinW");
                                    while((isNotDoppelt==false || keineDirektenNachbarn== false) && stopp==false){
                                        System.out.println("in WhileSchlaufe");

                                        if (nextInselWest == null) {
                                            xWest = r.nextInt((xbest - 2) + 1);
                                        }
                                        else {
                                            xWest = r.nextInt((xbest-2) - (xbest-abstandNextInselOKWest +1) +1) + (xbest-abstandNextInselOKWest +1);
                                        }

                                        anzahlBrueckenNeu = getRandomBruecke(); // wählt zufällig
                                        // Anzahl Brücke
                                        // zwischen 1 und 2

                                        inselNeu = new Insel(xWest, ybest, bestInselListe,
                                                Generator.countAnzInsel, anzahlBrueckenNeu, true, true, true, true);
                                        if(inselNeu == null) {
                                            System.out.println("inselNeu == null");
                                            continue;   
                                        }
                                        isNotDoppelt=pruefePositionBereitsVorhanden(inselNeu, bestInselListe);
                                        keineDirektenNachbarn=pruefeAufDirekteNachbarn(inselNeu);
                                        System.out.println( "pos nichtvorhandenWest: " +isNotDoppelt );
                                        System.out.println( "keineDirekteNachbarnWest: " +keineDirektenNachbarn );

                                        if(isNotDoppelt==false || keineDirektenNachbarn==false)
                                        {
                                            if(pruefePositionWest(bestInsel, inselNeu, bestInselListe,bestBrueckeListe)==true) {
                                                //nichtWaehlbareInselnListe.add(bestInsel);
                                                //waehlbareInselnListe.remove(bestInsel);
                                                stopp=true;
                                                bestInsel.setLoesbarW(false);
                                                //System.out.println( inselNeu.getId() +" in nichtWaehlbareInselnListe hinzugefügt" );
                                                //System.out.println( inselNeu.getId() +" in waehlbareInselnListe gelöscht");
                                            }
                                            System.out.println( inselNeu.getId() +" gelöscht: " );
                                            inselNeu = null;
                                            System.gc();

                                            if(stopp==true)
                                                System.out.println( "pos suchen wiederholen");


                                        }
                                        System.out.println( "pos nichtvorhandenWest: " +isNotDoppelt );

                                    }

                                    if(stopp==false && inselNeu != null) {

                                        //pruefeInselWiederverwendenBest(inselNeu, bestInsel, bestInselListe, waehlbareInselnListe, nichtWaehlbareInselnListe);
                                        brueckeNichtKreuzWest=pruefeKreuzungBrueckenWest(inselNeu, bestInsel, bestBrueckeListe);  //false, wenn Brücke gekreuzt wird: Insel wird gelöscht!

                                        // bei best Insel Anzahl Brücken anpassen
                                        //bruecken = bestInsel.anzahlBruecken + anzahlBrueckenNeu;

                                        //bestInsel.setAnzBrueckenNeu(bruecken);


                                        if(brueckeNichtKreuzWest) {
                                            inselNeu.setzeInsel(inselNeu, bestInselListe, waehlbareInselnListe);
                                            bestInsel.setLoesbarW(false);
                                            Generator.countAnzInsel++;
                                            if(anzahlBrueckenNeu==2)
                                                doppelt=true;
                                            else doppelt=false;
                                            brueckeNeu = new Bruecke(inselNeu.getId(), bestInsel.getId(), bestBrueckeListe, inselNeu.getPosInselX(), inselNeu.getPosInselY(), bestInsel.getPosInselX(), bestInsel.getPosInselY(), doppelt );
                                            brueckeNeu.setzeBruecke(brueckeNeu, bestBrueckeListe);
                                            //bestInsel.setAnzBrueckenNeu(countBrueckenBest);
                                            countBrueckenBest = countBrueckenBest+anzahlBrueckenNeu;
                                            bestInsel.setAnzBrueckenNeu(countBrueckenBest);
                                            //pruefeInselWiederverwendenBest(inselNeu, bestInsel, bestInselListe, waehlbareInselnListe, nichtWaehlbareInselnListe);
                                            pruefeInselWiederverwendenNeu(inselNeu, bestInselListe, waehlbareInselnListe, nichtWaehlbareInselnListe);

                                            System.out.println( "Koordinate Brücke: " +"start/end-ID: " + inselNeu.getId()  +", "+bestInsel.getId());
                                            System.out.println( "Anzahl Brücken best Brücke neu: " +countBrueckenBest);
                                            System.out.println( "Neue InselWest: " +inselNeu.getPosInselX() +", " +inselNeu.getPosInselY());
                                            System.out.println( "BestInsel lösbar: " +bestInsel.isLoesbarN() +", " +bestInsel.isLoesbarO()+", " +bestInsel.isLoesbarS()+", " +bestInsel.isLoesbarW());
                                            System.out.println( "Anzahl total Insel: " +Generator.countAnzInsel);
                                           
                                        }
                                        isNotDoppelt=false;
                                        keineDirektenNachbarn=false;
                                        stopp=false;
                                        pruefeInselWiederverwendenBest(bestInsel, bestInselListe, waehlbareInselnListe, nichtWaehlbareInselnListe);
                                    }
                                } else bestInsel.setLoesbarW(false);
                            }
                        }

                    }
                }

            }


        }


    }

 

[Josie]

Teil B:

 ////////////////////////////////////////////////////Methoden///////////////////////////////////

    /**
     *
     * Wählt zufällig eine Insel aus der wählbaren Inselliste und nimmt die zugehörige Insel mit allen
     * Daten aus der Gesamtliste.
     *
     * @param wahelbarListInseln Liste der wählbaren Inseln
     * @param listInseln Die Gesamtinselliste
     * @return Insel aus der Gesamtliste
     */

    // zufällig eine Insel aus der Liste wählen
    public static Insel getRandomItem(ArrayList<Insel> wahelbarListInseln, ArrayList<Insel> listInseln) {
        Insel ins= null;
        /*if (wahelbarListInseln.isEmpty()) { throw new IllegalArgumentException(
                "Die Insel-Liste ist leer!"); }
         */
        for (Insel w:wahelbarListInseln) {
            System.out.print("wählbareInselListe: "+w.getId() +", ");
        }
        System.out.println();

        for (Insel g:listInseln) {
            System.out.print("listInseln: "+g.getId() +", ");
        }
        System.out.println();

        Insel item = wahelbarListInseln.get(new Random().nextInt(wahelbarListInseln.size()));
        int idWaehlbarListe = item.getId();
        for(int i=0; i<listInseln.size(); i++) { //die Insel mit der gleichen ID aus der Gesamtliste nehmen
            if(idWaehlbarListe == listInseln.get(i).getId()) {

                ins= listInseln.get(i);
                System.out.println("Insel gewählte: " +ins.getPosInselX() +", " +ins.getPosInselY() +" ID: " +ins.getId() +"Anz Brücken: " +ins.getAnzBruecken());
                break;
            }
        }
        return ins;
    }


    /**
     * Gibt eine zufällige Anzahl von Brücken zwischen 1 und 2
     *
     * @return Anzahl Brücke zwischen 1 und 2
     */
    // zufällige Anzahl Brücken wählen
    public static int getRandomBruecke() {
        int anzahlBruecke = new Random().nextInt(2) + 1;
        return anzahlBruecke;
    }


    /**
     * Gibt der Abstand bis zur nächsten gekreuzte Brücke in Richtung Norden.
     * Wenn keine Brücke vorhanden, dann max Abstand bis zum Rand
     *
     * @param insel
     * @param alleBruecken Liste aller Brücken
     * @return Abstand bis zur nächsten gekreuzte Brücke im Norden
     */

    private int pruefeAbstandBisNaechsteBrueckeNord(Insel insel, ArrayList<Bruecke> alleBruecken){
        int maxN=insel.getPosInselY(); //maxNord;;
        int y;

        if(alleBruecken.isEmpty())
            return maxN;
        else for (int br=0; br<alleBruecken.size(); br++) {
            if((alleBruecken.get(br).getStartInselx() < insel.getPosInselX() && alleBruecken.get(br).getEndInselx() > insel.getPosInselX())  || (alleBruecken.get(br).getEndInselx() < insel.getPosInselX() && alleBruecken.get(br).getStartInselx() > insel.getPosInselX() )
                    && alleBruecken.get(br).getStartInsely() == alleBruecken.get(br).getEndInsely()
                    && alleBruecken.get(br).getStartInsely() < insel.getPosInselY()) {
                y = (insel.getPosInselY() -1) -alleBruecken.get(br).getStartInsely();
                if(y<maxN)
                    maxN=y;
                System.out.println("nächste Brücke Nord start/end-id: " +alleBruecken.get(br).getStartInselID() +", " +alleBruecken.get(br).getEndInselID());
            }
        }
        return maxN;
    }


    /**
     * Gibt der Abstand bis zur nächsten gekreuzte Brücke in Richtung Osten.
     * Wenn keine Brücke vorhanden, dann max Abstand bis zum Rand
     *
     * @param insel
     * @param alleBruecken Liste aller Brücken
     * @return Abstand bis zur nächsten gekreuzte Brücke im Osten
     */

    private int pruefeAbstandBisNaechsteBrueckeOst(Insel insel, ArrayList<Bruecke> alleBruecken){
        int maxO=Generator.breite- 1 -insel.getPosInselX(); //maxOst;
        int x;

        if(alleBruecken.isEmpty())
            return maxO;
        else for (int br=0; br<alleBruecken.size(); br++) {
            if((alleBruecken.get(br).getStartInsely() < insel.getPosInselY() && alleBruecken.get(br).getEndInsely() > insel.getPosInselY()) || (alleBruecken.get(br).getEndInsely() < insel.getPosInselY() && alleBruecken.get(br).getStartInsely() > insel.getPosInselY() )
                   && (alleBruecken.get(br).getStartInselx() == alleBruecken.get(br).getEndInselx())
                  
             
                    && (alleBruecken.get(br).getStartInselx() > insel.getPosInselX() )) {
                x = (alleBruecken.get(br).getStartInselx()-1) - insel.getPosInselX();
                if(x<maxO)
                    maxO=x;
                System.out.println("nächste Brücke Ost start/end-id: " +alleBruecken.get(br).getStartInselID() +", " +alleBruecken.get(br).getEndInselID());
            }
        }
        return maxO;
    }


    /**
     * Gibt der Abstand bis zur nächsten gekreuzte Brücke in Richtung Süden.
     * Wenn keine Brücke vorhanden, dann max Abstand bis zum Rand
     *
     * @param insel
     * @param alleBruecken Liste aller Brücken
     * @return Abstand bis zur nächsten gekreuzte Brücke im Süden
     */

    private int pruefeAbstandBisNaechsteBrueckeSued(Insel insel, ArrayList<Bruecke> alleBruecken){
        int maxS=Generator.hoehe-1 -insel.getPosInselY(); //maxSued;;
        int y;

        if(alleBruecken.isEmpty())
            return maxS;
        else for (int br=0; br<alleBruecken.size(); br++) {
            if((alleBruecken.get(br).getStartInselx() < insel.getPosInselX() &&  alleBruecken.get(br).getEndInselx() > insel.getPosInselX()) || (alleBruecken.get(br).getEndInselx() < insel.getPosInselX() &&  alleBruecken.get(br).getStartInselx() > insel.getPosInselX()  )
                    && alleBruecken.get(br).getEndInsely() == alleBruecken.get(br).getStartInsely()
                    && alleBruecken.get(br).getStartInsely() > insel.getPosInselY()) {
                y = (alleBruecken.get(br).getStartInsely()-1) - insel.getPosInselY() ;
                if(y<maxS)
                    maxS=y;
                System.out.println("nächste Brücke Süd start/end-id: " +alleBruecken.get(br).getStartInselID() +", " +alleBruecken.get(br).getEndInselID());
            }
        }
        return maxS;
    }


    /**
     * Gibt der Abstand bis zur nächsten gekreuzte Brücke in Richtung Westen.
     * Wenn keine Brücke vorhanden, dann max Abstand bis zum Rand
     *
     * @param insel
     * @param alleBruecken Liste aller Brücken
     * @return Abstand bis zur nächsten gekreuzte Brücke im Westen
     */

    private int pruefeAbstandBisNaechsteBrueckeWest(Insel insel, ArrayList<Bruecke> alleBruecken){
        int maxW=insel.getPosInselX(); //maxWest;;
        int x;

        if(alleBruecken.isEmpty())
            return maxW;
        else for (int br=0; br<alleBruecken.size(); br++) {
            if((alleBruecken.get(br).getStartInsely() < insel.getPosInselY() && alleBruecken.get(br).getEndInsely() > insel.getPosInselY()) || (alleBruecken.get(br).getEndInsely() < insel.getPosInselY() && alleBruecken.get(br).getStartInsely() > insel.getPosInselY())
            && (alleBruecken.get(br).getStartInselx() == alleBruecken.get(br).getEndInselx())
            && (alleBruecken.get(br).getStartInselx() < insel.getPosInselX()) ) {
                x = (insel.getPosInselX() -1) - alleBruecken.get(br).getStartInselx() ;
                if(x<maxW)
                    maxW=x;
                System.out.println("nächste Brücke West start/end-id: " +alleBruecken.get(br).getStartInselID() +", " +alleBruecken.get(br).getEndInselID());
            }
        }
        return maxW;
    }

    /**
     * Prüft Position im Norden. Stoppt While-Schleife, wenn Position setzen nicht möglich ist
     *
     *
     * @param inselBest
     * @param inselNeu
     * @param alleInseln Die Gesamtinselliste
     * @param alleBruecken Die Liste aller Brücken
     * @return true, wenn die Insel direkt neben einer Brücke liegt und zusätzlich nur eine Position möglich ist oder die
     * erste Brücke liegt mit einem Abstand von der bestehenden Insel entfernt
     */

    //gibts eine Brücke, die gerade neben der neuen Insel steht und direkte Nachbarn hat und nur 1 Position zum setzen hat?
    private boolean pruefePositionNord(Insel inselBest, Insel inselNeu, ArrayList<Insel> alleInseln, ArrayList<Bruecke> alleBruecken) {
        boolean stoppN=false;
        int abstandN=pruefeAbstandBisNaechsteBrueckeNord(inselNeu, alleBruecken); // Abstand bis nächste gekreuzte Brücke Nord, sonst max Abstand bis Rand
        int abstandBestN=pruefeAbstandBisNaechsteBrueckeNord(inselBest, alleBruecken); // Abstand von der bestehenden Insel bis nächste gekreuzte Brücke Nord, sonst max Abstand bis Rand
        int abstandInselN=pruefeAbstandBisNaechsteInselNord(inselBest, inselNeu, alleInseln); //Abstand bestehenden Insel bis nächste Insel, sonst max Abstand bis Rand
        boolean nachbarn=pruefeAufDirekteNachbarn(inselNeu);

        if(alleBruecken.isEmpty())
            return stoppN=false;
        else if (abstandN==inselNeu.getPosInselY()) //maxNord)
            return stoppN=false; // dann gibts keine Bruecke, setzen überall möglich
        else  if(abstandN==0 && abstandInselN<=2 && nachbarn==true)  {  // die Brücke liegt neben Insel &&    nur 1 Möglichkeit zum setzen
            stoppN=true;
            inselBest.setLoesbarN(false);
            System.out.println("stopp=true: neue Insel liegt neben Brücke und hat nur eine möglichkeit zum setzen");
        }
        else if(abstandBestN<=2) { // Brücke liegt mit einem Abstand neben bestehenden Insel, keine Insel setzbar!
          
            inselBest.setLoesbarN(false);;
        return stopp=true;
        }
      
        else stoppN=false;


        return stoppN;
    }


    /**
     * Prüft Position im Osten. Stoppt While-Schleife, wenn Position setzen nicht möglich ist
     *
     *
     * @param inselBest
     * @param inselNeu
     * @param alleInseln Die Gesamtinselliste
     * @param alleBruecken Die Liste aller Brücken
     * @return true, wenn die Insel direkt neben einer Brücke liegt und zusätzlich nur eine Position möglich ist oder die
     * erste Brücke liegt mit einem Abstand von der bestehenden Insel entfernt
     */

    //gibts eine Brücke, die gerade neben der neuen Insel steht und direkte Nachbarn hat und nur 1 Position zum setzen hat?
    private boolean pruefePositionOst(Insel inselBest, Insel inselNeu, ArrayList<Insel> alleInseln, ArrayList<Bruecke> alleBruecken) {
        boolean stoppO=false;
        int abstandO=pruefeAbstandBisNaechsteBrueckeOst(inselNeu, alleBruecken); // Abstand bis nächste gekreuzte Brücke Ost, sonst max Abstand bis Rand
        int abstandBestO=pruefeAbstandBisNaechsteBrueckeOst(inselBest, alleBruecken); // Abstand von der bestehenden Insel bis nächste gekreuzte Brücke Ost, sonst max Abstand bis Rand
        int abstandInselO=pruefeAbstandBisNaechsteInselOst(inselBest, inselNeu, alleInseln); //Abstand bestehenden Insel bis nächste Insel, sonst max Abstand bis Rand
        boolean nachbarn=pruefeAufDirekteNachbarn(inselNeu); // true, wenn Nachbarn und nicht am Rand

        if(alleBruecken.isEmpty())
            return stoppO=false;
        else if (abstandO==Generator.breite-1-inselNeu.getPosInselX()) //maxOst)
            return stoppO=false; // dann gibts keine Bruecke, setzen überall möglich
        else  if(abstandO==0 && abstandInselO<=2 && nachbarn==true)  {  // die Brücke liegt neben Insel &&    nur 1 Möglichkeit zum setzen
            stoppO=true;
            inselBest.setLoesbarO(false);
            System.out.println("stopp=true: neue Insel liegt neben Brücke und hat nur eine möglichkeit zum setzen");
        }
        else if(abstandBestO<=2) {
            inselBest.setLoesbarO(false);// Brücke liegt mit einem Abstand neben bestehenden Insel, keine Insel setzbar!
      
            return stopp=true;
        }
        else stoppO=false;

        return stoppO;
    }

    /**
     * Prüft Position im Süden. Stoppt While-Schleife, wenn Position setzen nicht möglich ist
     *
     *
     * @param inselBest
     * @param inselNeu
     * @param alleInseln Die Gesamtinselliste
     * @param alleBruecken Die Liste aller Brücken
     * @return true, wenn die Insel direkt neben einer Brücke liegt und zusätzlich nur eine Position möglich ist oder die
     * erste Brücke liegt mit einem Abstand von der bestehenden Insel entfernt
     */

    //gibts eine Brücke, die gerade neben der neuen Insel steht und direkte Nachbarn hat und nur 1 Position zum setzen hat?
    private boolean pruefePositionSued(Insel inselBest, Insel inselNeu, ArrayList<Insel> alleInseln, ArrayList<Bruecke> alleBruecken) {
        boolean stoppS=false;
        int abstandS=pruefeAbstandBisNaechsteBrueckeSued(inselNeu, alleBruecken); // Abstand bis nächste gekreuzte Brücke Süd, sonst max Abstand bis Rand
        int abstandBestS=pruefeAbstandBisNaechsteBrueckeSued(inselBest, alleBruecken); // Abstand von der bestehenden Insel bis nächste gekreuzte Brücke Süd, sonst max Abstand bis Rand
        int abstandInselS=pruefeAbstandBisNaechsteInselSued(inselBest, inselNeu, alleInseln); //Abstand bestehenden Insel bis nächste Insel, sonst max Abstand bis Rand
        boolean nachbarn=pruefeAufDirekteNachbarn(inselNeu); // true, wenn Nachbarn und nicht am Rand

        if(alleBruecken.isEmpty())
            return stoppS=false;
        else if (abstandS==Generator.hoehe-1-inselNeu.getPosInselY()) //maxSued)
            return stoppS=false; // dann gibts keine Bruecke, setzen überall möglich
        else  if(abstandS==0 && abstandInselS<=2 && nachbarn==true)  {  // die Brücke liegt neben Insel &&    nur 1 Möglichkeit zum setzen
            stoppS=true;
            inselBest.setLoesbarS(false);;
            System.out.println("stopp=true: neue Insel liegt neben Brücke und hat nur eine möglichkeit zum setzen");
        }
        else if(abstandBestS<=2) {  // Brücke liegt mit einem Abstand neben bestehenden Insel, keine Insel setzbar!
            inselBest.setLoesbarS(false);
            return stopp=true;
        }
        else stoppS=false;

        return stoppS;
    }


    /**
     * Prüft Position im Westen. Stoppt While-Schleife, wenn Position setzen nicht möglich ist
     *
     *
     * @param inselBest
     * @param inselNeu
     * @param alleInseln Die Gesamtinselliste
     * @param alleBruecken Die Liste aller Brücken
     * @return true, wenn die Insel direkt neben einer Brücke liegt und zusätzlich nur eine Position möglich ist oder die
     * erste Brücke liegt mit einem Abstand von der bestehenden Insel entfernt
     */
    //gibts eine Brücke, die gerade neben der neuen Insel steht und direkte Nachbarn hat und nur 1 Position zum setzen hat?
    private boolean pruefePositionWest(Insel inselBest, Insel inselNeu, ArrayList<Insel> alleInseln, ArrayList<Bruecke> alleBruecken) {
        boolean stoppW=false;
        int abstandW=pruefeAbstandBisNaechsteBrueckeWest(inselNeu, alleBruecken); // Abstand bis nächste gekreuzte Brücke West, sonst max Abstand bis Rand
        int abstandBestW=pruefeAbstandBisNaechsteBrueckeWest(inselBest, alleBruecken); // Abstand von der bestehenden Insel bis nächste gekreuzte Brücke West, sonst max Abstand bis Rand
        int abstandInselW=pruefeAbstandBisNaechsteInselWest(inselBest, inselNeu, alleInseln); //Abstand bestehenden Insel bis nächste Insel, sonst max Abstand bis Rand
        boolean nachbarn=pruefeAufDirekteNachbarn(inselNeu); // true, wenn Nachbarn und nicht am Rand

        if(alleBruecken.isEmpty())
            return stoppW=false;
        else if (abstandW== inselNeu.getPosInselX()) //maxWest)
            return stoppW=false; // dann gibts keine Bruecke, setzen überall möglich
        else  if(abstandW==0 && abstandInselW<=2 && nachbarn==true)  {  // die Brücke liegt neben Insel &&    nur 1 Möglichkeit zum setzen
            stoppW=true;
            inselBest.setLoesbarW(false);;
            System.out.println("stopp=true: neue Insel liegt neben Brücke und hat nur eine möglichkeit zum setzen");
        }
        else if(abstandBestW<=2) {// Brücke liegt mit einem Abstand neben bestehenden Insel, keine Insel setzbar!
            inselBest.setLoesbarW(false);
            return stopp=true;
        }
        else stoppW=false;

        return stoppW;
    }

    /**
     * Prüft, ob die Insel direkte Nachbarn besitzt.
     *
     * @param insel
     * @return false, wenn direkte Nachbarn gibt
     */

    private boolean pruefeAufDirekteNachbarn(Insel insel) {
        int abstandNord;
        int abstandOst;
        int abstandSued;
        int abstandWest;
        boolean abstandOk;

        //nächste Insel suchen, null wenn keine gibt
        Insel nextInselN= naechsteInselNord(insel, bestInselListe);
        Insel nextInselO= naechsteInselOst(insel, bestInselListe);
        Insel nextInselS= naechsteInselSued(insel, bestInselListe);
        Insel nextInselW= naechsteInselWest(insel, bestInselListe);

        //Abstand, bis nächster Insel, wenn keine Abstand bis zum Rand
        abstandNord =pruefeAbstandBisNaechsteInselNord(insel, nextInselN, bestInselListe);
        abstandOst =pruefeAbstandBisNaechsteInselOst(insel, nextInselO, bestInselListe);
        abstandSued =pruefeAbstandBisNaechsteInselSued(insel, nextInselS, bestInselListe);
        abstandWest =pruefeAbstandBisNaechsteInselWest(insel, nextInselW, bestInselListe);

        //if((abstandNord==1 && nextInselN != null)|| (abstandOst==1 && nextInselO != null)|| (abstandSued==1 && nextInselS != null)|| (abstandWest==1 && nextInselW != null)) {

        //Abstand bis nächste Insel ist 0 und liegt nicht am Rand
      
      
        if((abstandNord==0 && insel.getPosInselY() != 0) || (abstandOst==0 && insel.getPosInselX() != Generator.breite-1) || (abstandSued==0 && insel.getPosInselY() != Generator.hoehe - 1) || (abstandWest==0 && insel.getPosInselX() != 0)  ) {
            abstandOk = false;
            System.out.println("Man kann keine Insel setzen! (Nachbarn)");
        }
        else abstandOk = true;


        return abstandOk; 
    }


    /**
     * Sucht die in Richtung Norden am nächsten gelegene Insel.
     * Wenn keine Insel in diese Richtung vorhanden ist, wird null zurückgegeben.
     *
     * @param insel
     * @param listInseln Die GesamtinselListe
     * @return Insel, die im Norden am nächsten der gewählten Insel liegt
     */

    //gibt die nächste Insel zurück, null wenn keine andere vorhanden ist
    public Insel naechsteInselNord(Insel insel, ArrayList<Insel> listInseln) {
        int y;
        Insel ins = null;
        int max = Generator.hoehe; //Generator.hoehe-1-bestInsel.getPosInselY();
        for(int i=0; i<listInseln.size(); i++) {

                //System.out.println("bestInsel: " + insel.getPosInselX() +", " +insel.getPosInselY());
            //gibts eine Insel, die im Norden liegt
            if(listInseln.get(i).getPosInselX() == insel.getPosInselX() && listInseln.get(i).getPosInselY() < insel.getPosInselY()) {
                // Differenz y best und insel(i)
                y = (insel.getPosInselY() -1 ) - listInseln.get(i).getPosInselY();
                // die kleinere Differenz nehmen
                if (y<max) {
                    /*// wenn best Insel, dann der letzte Wert nehmen
                    if(listInseln.get(i).equals(bestInsel)) // wenn gleich, dann maximum
                        return ins;
                    else {*/
                    max=y;
                    ins=listInseln.get(i);

                }
            }
        }

        return ins;
    }


    /**
     * Sucht die in Richtung Osten am nächsten gelegene Insel.
     * Wenn keine Insel in diese Richtung vorhanden ist, wird null zurückgegeben.
     *
     * @param insel
     * @param listInseln Die GesamtinselListe
     * @return Insel, die im Osten am nächsten der gewählten Insel liegt
     */

    //gibt die nächste Insel zurück, null wenn keine andere vorhanden ist
    public Insel naechsteInselOst(Insel insel, ArrayList<Insel> listInseln) {
        int x;
        Insel ins = null;
        int max = Generator.breite; //Generator.breite-1-bestInsel.getPosInselX();
        for(int i=0; i<listInseln.size(); i++) {

            //System.out.println("bestInsel.getPosInselX()" + insel.getPosInselX());
            //System.out.println("bestInsel.getPosInselY()" + insel.getPosInselY());

            //gibts eine Insel, die im Osten liegt mit gleichen y-Wert
            if(listInseln.get(i).getPosInselY() == insel.getPosInselY() && listInseln.get(i).getPosInselX() > insel.getPosInselX()) {
                // Differenz y best und insel(i)
                x = (listInseln.get(i).getPosInselX() -1) - insel.getPosInselX() ;
                // die kleinere Differenz nehmen
                if (x<max) {
                    /*// wenn best Insel, dann der letzte Wert nehmen
                    if (listInseln.get(i).equals(bestInsel)) // wenn gleich, dann maximum
                        return ins;
                    else {*/ 
                    max=x;
                    ins=listInseln.get(i);

                }
            }

        }

        return ins;
    }


    /**
     * Sucht die in Richtung Süden am nächsten gelegene Insel.
     * Wenn keine Insel in diese Richtung vorhanden ist, wird null zurückgegeben.
     *
     * @param insel
     * @param listInseln Die GesamtinselListe
     * @return Insel, die im Süden am nächsten der gewählten Insel liegt
     */

    //gibt die nächste Insel zurück, null wenn keine andere vorhanden ist
    public Insel naechsteInselSued(Insel insel, ArrayList<Insel> listInseln) {
        int y;
        Insel ins = null;
        int max = Generator.hoehe; //bestInsel.getPosInselY();
        for(int i=0; i<listInseln.size(); i++) {

            //System.out.println("bestInsel.getPosInselX()" + insel.getPosInselX());
            //System.out.println("bestInsel.getPosInselY()" + insel.getPosInselY());

            //gibts eine Insel, die im Süden liegt
            if(listInseln.get(i).getPosInselX() == insel.getPosInselX() && listInseln.get(i).getPosInselY() > insel.getPosInselY()) {
                // Differenz y best und insel(i)
                y = (listInseln.get(i).getPosInselY() -1) - insel.getPosInselY() ;
                // die kleinere Differenz nehmen
                if (y<max) {
                    /*// wenn best Insel, dann der letzte Wert nehmen
                    if(listInseln.get(i).equals(bestInsel)) // wenn gleich, dann maximum
                        return ins;
                    else { */
                    max=y;
                    ins=listInseln.get(i);

                }
            }

        }

        return ins;
    }


    /**
     * Sucht die in Richtung Westen am nächsten gelegene Insel.
     * Wenn keine Insel in diese Richtung vorhanden ist, wird null zurückgegeben.
     *
     * @param insel
     * @param listInseln Die GesamtinselListe
     * @return Insel, die im Westen am nächsten der gewählten Insel liegt
     */

    //gibt die nächste Insel zurück, null wenn keine andere vorhanden ist
    public Insel naechsteInselWest(Insel insel, ArrayList<Insel> listInseln) {
        int x;
        Insel ins = null;
        int max =  Generator.breite; //bestInsel.getPosInselX();
        for(int i=0; i<listInseln.size(); i++) {

            //System.out.println("bestInsel.getPosInselX()" + insel.getPosInselX());
            //System.out.println("bestInsel.getPosInselY()" + insel.getPosInselY());

            //gibts eine Insel, die im Westen liegt
            if(listInseln.get(i).getPosInselY() == insel.getPosInselY() && listInseln.get(i).getPosInselX() < insel.getPosInselX()) {
                // Differenz y best und insel(i)
                x = (insel.getPosInselX() -1 ) - listInseln.get(i).getPosInselX();
                // die kleinere Differenz nehmen
                if (x<max) {
                    /*// wenn best Insel, dann der letzte Wert nehmen
                    if(listInseln.get(i).equals(bestInsel)) // wenn gleich, dann maximum
                        return ins;
                    else {*/
                    max=x;
                    ins=listInseln.get(i);
                } 

            }

        }

        return ins;
    }


    /**
     * Gibt den Abstand zur nächsten Insel in Richtung Norden.
     * Wenn es keine nächste Insel im Westen gibt, der Abstand bis zum Rand.
     *
     * @param insel
     * @param nextInsel
     * @param listInseln Gesamtinselliste
     * @return Abstand bis zur nächsten Insel in Richtung Norden
     */

    //gibt der Abstand bis zur nächsten Insel
    private int pruefeAbstandBisNaechsteInselNord(Insel insel, Insel nextInsel,ArrayList<Insel> listInseln) {
        int abstand = insel.getPosInselY();
        if(nextInselNord==null) {
            return abstand=insel.getPosInselY();//maxNord;
        }
        else {
            if(nextInsel != null)
                abstand = (insel.getPosInselY()-1) - nextInsel.getPosInselY();
        }
        return abstand;
        /*;
        int max = Generator.hoehe;
        for(int i=0; i<listInseln.size(); i++) {
            // wenn best Insel, dann der letzte Wert nehmen
            if(listInseln.get(i).equals(bestInsel)) // wenn gleich, dann maximum
                return max;
            //gibts eine Insel, die im Norden liegt
            else if(listInseln.get(i).getPosInselX() == bestInsel.getPosInselX() && listInseln.get(i).getPosInselY() < bestInsel.getPosInselY()) {
                // Differenz y best und insel(i)
                y = (bestInsel.getPosInselY() -1 ) - listInseln.get(i).getPosInselY();
                // die kleinere Differenz nehmen
                if (y<max)
                    max=y;
            }
        }

        return max; */
    }


    /**
     * Gibt den Abstand zur nächsten Insel in Richtung Osten.
     * Wenn es keine nächste Insel im Westen gibt, der Abstand bis zum Rand.
     *
     * @param insel
     * @param nextInsel
     * @param listInseln Gesamtinselliste
     * @return Abstand bis zur nächsten Insel in Richtung Osten
     */

    //gibt der Abstand bis zur nächsten Insel
    private int pruefeAbstandBisNaechsteInselOst(Insel insel, Insel nextInsel, ArrayList<Insel> listInseln) {

        int abstand = (Generator.breite -1) -insel.getPosInselX();
        if(nextInselOst==null) {
            return abstand= Generator.breite - 1 - insel.getPosInselX();// maxOst;
        }
        else {
            if(nextInsel != null)
                abstand = (nextInsel.getPosInselX()-1) - insel.getPosInselX();
        }
        return abstand;
        /*
        int y;
        int max = Generator.breite;
        for(int i=0; i<listInseln.size(); i++) {
            // wenn best Insel, dann der letzte Wert nehmen
            if(listInseln.get(i).equals(bestInsel)) // wenn gleich, dann maximum
                return max;
            //gibts eine Insel, die im Osten liegt
            else if(listInseln.get(i).getPosInselY() == bestInsel.getPosInselY() && listInseln.get(i).getPosInselX() > bestInsel.getPosInselX()) {
                // Differenz y best und insel(i)
                y = (listInseln.get(i).getPosInselX() -1) - bestInsel.getPosInselX() ;
                // die kleinere Differenz nehmen
                if (y<max)
                    max=y;
            }
        }

        return max; */
    }


    /**
     * Gibt den Abstand zur nächsten Insel in Richtung Süden.
     * Wenn es keine nächste Insel im Westen gibt, der Abstand bis zum Rand.
     *
     * @param insel
     * @param nextInsel
     * @param listInseln Gesamtinselliste
     * @return Abstand bis zur nächsten Insel in Richtung Süden
     */


    //gibt der Abstand bis zur nächsten Insel
    private int pruefeAbstandBisNaechsteInselSued(Insel insel, Insel nextInsel,ArrayList<Insel> listInseln) {
        int abstand = (Generator.hoehe-1) -insel.getPosInselY();
        if(nextInselSued==null) {
            return abstand= Generator.hoehe - 1 - insel.getPosInselY();// maxSued;
        }
        else {
            if(nextInsel != null)
                abstand = (nextInsel.getPosInselY()-1) - insel.getPosInselY();
        }
        return abstand;
        /*
        int y;
        int max = Generator.hoehe;
        for(int i=0; i<listInseln.size(); i++) {
            // wenn best Insel, dann der letzte Wert nehmen
            if(listInseln.get(i).equals(bestInsel)) // wenn gleich, dann maximum
                return max;
            //gibts eine Insel, die im Süden liegt
            else if(listInseln.get(i).getPosInselX() == bestInsel.getPosInselX() && listInseln.get(i).getPosInselY() > bestInsel.getPosInselY()) {
                // Differenz y best und insel(i)
                y = (listInseln.get(i).getPosInselY() -1) - bestInsel.getPosInselY() ;
                // die kleinere Differenz nehmen
                if (y<max)
                    max=y;
            }
        }

        return max; */
    }


    /**
     * Gibt den Abstand zur nächsten Insel in Richtung Westen.
     * Wenn es keine nächste Insel im Westen gibt, der Abstand bis zum Rand.
     *
     * @param insel
     * @param nextInsel
     * @param listInseln Gesamtinselliste
     * @return Abstand bis zur nächsten Insel in Richtung Westen
     */

    //gibt der Abstand bis zur nächsten Insel
    private int pruefeAbstandBisNaechsteInselWest(Insel insel,Insel nextInsel, ArrayList<Insel> listInseln) {
        int abstand = insel.getPosInselX();
        if(nextInselWest==null) {
            return abstand= insel.getPosInselX();// maxWest;
        }
        else {
            if(nextInsel != null)
                abstand = (insel.getPosInselX()-1) - nextInsel.getPosInselX() ;
        }
        return abstand;
        /*
        int y;
        int max = Generator.breite;
        for(int i=0; i<listInseln.size(); i++) {
            // wenn best Insel, dann der letzte Wert nehmen
            if(listInseln.get(i).equals(bestInsel)) // wenn gleich, dann maximum
                return max;
            //gibts eine Insel, die im Westen liegt
            else if(listInseln.get(i).getPosInselY() == bestInsel.getPosInselY() && listInseln.get(i).getPosInselX() < bestInsel.getPosInselX()) {
                // Differenz y best und insel(i)
                y = (bestInsel.getPosInselX() -1 ) - listInseln.get(i).getPosInselX();
                // die kleinere Differenz nehmen
                if (y<max)
                    max=y;
            }
        }

        return max; */
    }

 

[Josie]

noch ein dritter Teil der Klasse Insel:

    // prüft, ob eine Insel am Rand bereits liegt, wenn nur 2 Felder möglich sind
    private boolean pruefeInselAmRandNord(Insel bestInsel, ArrayList<Insel> listInseln) {
        if(maxNord==2) {
            for (Insel ins:listInseln) {
                if (ins.posInselX==bestInsel.getPosInselX() && ins.getPosInselY()==0) {
                    posInselAmRandNord=true; //Insel setzen nicht möglich
                    break;
                }
            }
        }
        return posInselAmRandNord;
    }

    private boolean pruefeInselAmRandOst(Insel bestInsel, ArrayList<Insel> listInseln) {
        if(maxOst==2) {
            for (Insel ins:listInseln) {
                if (ins.posInselY==bestInsel.getPosInselY() && ins.getPosInselY()==(Generator.breite-1)) {
                    posInselAmRandOst=true; //Insel setzen nicht möglich
                    break;
                }
            }
        }
        return posInselAmRandOst;
    }

    private boolean pruefeInselAmRandSued(Insel bestInsel, ArrayList<Insel> listInseln) {
        if(maxSued==2) {
            for (Insel ins:listInseln) {
                if (ins.posInselX==bestInsel.getPosInselX() && ins.getPosInselY()==Generator.breite) {
                    posInselAmRandSued=true; //Insel setzen nicht möglich
                    break;
                }
            }
        }
        return posInselAmRandSued;
    }



    private boolean pruefeInselAmRandWest(Insel insel, ArrayList<Insel> listInseln) {
        if(maxWest==2) {
            for (Insel ins:listInseln) {
                if (ins.posInselY==insel.getPosInselY() && ins.getPosInselY()==0) {
                    posInselAmRandWest=true; //Insel setzen nicht möglich
                    break;
                }
            }
        }
        return posInselAmRandWest;
    }
  

    /**
     *
     * Wenn die Insel nicht null und die Insel am Rand liegt, wird die Brückenliste durchsucht.
     *
     * @param insel
     * @param listInseln Die Gesamtinselliste
     * @param listBruecken Liste aller Brücken
     * @return true, wenn Insel im Norden mit Brücken verunden ist
     */

    // prüft, ob in der nördlichen Richtung bereits mit einer Insel verbunden wurde
    private boolean pruefeMitBrueckeVerbundenNord(Insel bestInsel, ArrayList<Insel> listInseln, ArrayList<Bruecke> listBruecken) {
        // Insel-Liste mit Brücken-Liste vergleichen
        if(listInseln.isEmpty() || listBruecken.isEmpty())
            brueckeAufLinieNord = false;
        else if (bestInsel != null && bestInsel.getPosInselY()==0)
            brueckeAufLinieNord=true;
        else { /*
            for (Insel ins:listInseln) {
                //wenn x-Wert der Insel aus Liste gleich wie die best Insel ist
                if (ins.getPosInselX() == bestInsel.getPosInselX()) {
                    //dann in der Brücken-Liste überprüfen, ob End-Id= Id der bestInsel ist
                    for (Bruecke br: listBruecken) {
                        if(br.getEndInselID() == bestInsel.getId()) {
                            brueckeAufLinieNord=true;
                            break;
                        }
                    }
                }
                // else Brücke auf Kreuzung überprüfen!! Sonst Insel/Brücke setzbar
            } */
            for (Bruecke br:listBruecken) {
                // gibt es eine Brücke, die die gleiche End-ID besitzt  und die auf der gleiche Linie (y-Wert) wie best Insel
                if(bestInsel != null && br.getEndInselID() == bestInsel.getId() && br.getStartInselx() == bestInsel.getPosInselX()) {
                    brueckeAufLinieNord=true;
                    break;
                } else brueckeAufLinieNord=false;
            }
        }

        return brueckeAufLinieNord;

    }


    /**
     *
     * Wenn die Insel nicht null und die Insel am Rand liegt, wird die Brückenliste durchsucht.
     *
     * @param insel
     * @param listInseln Die Gesamtinselliste
     * @param listBruecken Liste aller Brücken
     * @return true, wenn Insel im Osten mit Brücken verunden ist
     */

    private boolean pruefeMitBrueckeVerbundenOst(Insel bestInsel, ArrayList<Insel> listInseln, ArrayList<Bruecke> listBruecken) {
        // Insel-Liste mit Brücken-Liste vergleichen
        if(listInseln.isEmpty() || listBruecken.isEmpty())
            brueckeAufLinieOst = false;
        else if (bestInsel != null && bestInsel.getPosInselX() == (Generator.breite-1))
            brueckeAufLinieOst=true;
        else {
            /*
            for (Insel ins:listInseln) {
                //wenn y-Wert der Insel aus Inselliste gleich ist wie Y-Wert der best Insel
                if (ins.getPosInselY() == bestInsel.getPosInselY()) {
                    //dann in der Brücken-Liste überprüfen, ob Start-Id= Id der bestInsel ist
                    for (Bruecke br: listBruecken) {
                        if(br.getStartInselID() == bestInsel.getId()) {
                            brueckeAufLinieOst=true;
                            break;
                        }
                    }
                }
                // else Brücke auf Kreuzung überprüfen!! Sonst Insel/Brücke setzbar
            } */
            for (Bruecke br:listBruecken) {
                // gibt es eine Brücke, die die gleiche StartID besitzt  und die auf der gleiche Linie (y-Wert) wie best Insel
                if(bestInsel != null && br.getStartInselID() == bestInsel.getId() && br.getEndInsely() == bestInsel.getPosInselY()) {
                    brueckeAufLinieOst=true;
                    break;
                } else brueckeAufLinieOst=false;
            }
        }

        return brueckeAufLinieOst;

    }

    /*
         // Insel-Liste mit Brücken-Liste vergleichen

        for (int i = 0; i < listInseln.size(); i++) {
            for (int k = 0; k < listBruecken.size(); k++) {


                // Ost
                //wenn gleiche id vorhanden
                if (listInseln.get(i).getId() == listBruecken.get(k).getEndInselID()) {
                    //dann in der Insel-Liste die zugehörige Insel zur ID suchen
                    for (Insel ins:listInseln) {
                        if(ins.getId()==listBruecken.get(k).getEndInselID())
                            //wenn die Y-Position übereinstimme (für Ost)
                            if(ins.getPosInselY()==listInseln.get(i).getPosInselY())
                                brueckeAufLinieOst=true;
                    }
                }
                else   brueckeAufLinieOst = false;
                // Insel wählen und setzen möglich
            }
        }
        return brueckeAufLinieOst;
    } */


    /**
     *
     * Wenn die Insel nicht null und die Insel am Rand liegt, wird die Brückenliste durchsucht.
     *
     * @param insel
     * @param listInseln Die Gesamtinselliste
     * @param listBruecken Liste aller Brücken
     * @return true, wenn Insel im Süden mit Brücken verunden ist
     */
    private boolean pruefeMitBrueckeVerbundenSued(Insel bestInsel, ArrayList<Insel> listInseln, ArrayList<Bruecke> listBruecken) {
        // Insel-Liste mit Brücken-Liste vergleichen
        if(listInseln.isEmpty() || listBruecken.isEmpty())
            brueckeAufLinieSued = false;
        else if (bestInsel != null && bestInsel.getPosInselY() == (Generator.hoehe-1))
            brueckeAufLinieSued=true;
        else { /*
            for (Insel ins:listInseln) {
                //wenn gleiche X
                if (ins.getPosInselX() == bestInsel.getPosInselX()) {
                    //dann in der Brücken-Liste überprüfen, ob Start-Id= Id der bestInsel ist
                    for (Bruecke br: listBruecken) {
                        if(br.getStartInselID() == bestInsel.getId()) {
                            brueckeAufLinieSued=true;
                            break;
                        }
                    }
                }
                // else Brücke auf Kreuzung überprüfen!! Sonst Insel/Brücke setzbar
            } */
            for (Bruecke br:listBruecken) {
                // gibt es eine Brücke, die die gleiche StartID besitzt  und die auf der gleiche Linie (y-Wert) wie best Insel
                if(bestInsel != null && br.getStartInselID() == bestInsel.getId() && br.getEndInselx() == bestInsel.getPosInselX()) {
                    brueckeAufLinieSued=true;
                    break;
                } else brueckeAufLinieSued=false;
            }
        }

        return brueckeAufLinieSued;

    }


    /**
     *
     * Wenn die Insel nicht null und die Insel am Rand liegt, wird die Brückenliste durchsucht.
     *
     * @param insel
     * @param listInseln Die Gesamtinselliste
     * @param listBruecken Liste aller Brücken
     * @return true, wenn Insel im Westen mit Brücken verunden ist
     */

    private boolean pruefeMitBrueckeVerbundenWest(Insel insel, ArrayList<Insel> listInseln, ArrayList<Bruecke> listBruecken) {
        // Insel-Liste mit Brücken-Liste vergleichen
        if(listInseln.isEmpty() || listBruecken.isEmpty())
            brueckeAufLinieWest = false;
        else if (insel != null && insel.getPosInselX() == 0)
            brueckeAufLinieWest=true;
        else { /*
            for (Insel ins:listInseln) {
                //wenn y-Wert der Insel aus Inselliste gleiche ist wie der Y-Wert der best Insel
                if (ins.getPosInselY() == bestInsel.getPosInselY()) {
                    //dann in der Brücken-Liste überprüfen, ob End-Id= Id der bestInsel ist
                    for (Bruecke br: listBruecken) {
                        if(br.getEndInselID() == bestInsel.getId()) {
                            brueckeAufLinieWest=true;
                            break;
                        }
                    }
                }
                // else Brücke auf Kreuzung überprüfen!! Sonst Insel/Brücke setzbar
            } */
            for (Bruecke br:listBruecken) {
                // gibt es eine Brücke, die die gleiche EndID besitzt  und die auf der gleiche Linie (y-Wert) wie best Insel
                if(insel != null && br.getEndInselID() == insel.getId() && br.getStartInsely() == insel.getPosInselY()) {
                    brueckeAufLinieWest=true;
                    break;
                } else brueckeAufLinieWest=false;
            }
        }

        return brueckeAufLinieWest;

    }


    /**
     * Prüft, ob die neu gesetzte Insel in Rchtung Norden keine Brücke kreuzt.
     * Wenn die Brückenliste nicht leer ist und die Insel nicht null ist, wird die Brückenliste durchsucht.
     * Wenn die Insel eine Brücke kreuzt, wird die Insel im Norden wieder gelöscht.
     *
     *
     * @param inselNeu Die neue Insel
     * @param inselBest Die bestehende Insel
     * @param listBruecken Alle bereits gesetzten Brücken
     * @return false, wenn die gesetzte Insel eine Brücke kreuzt
     */

    private boolean pruefeKreuzungBrueckenNord(Insel inselNeu, Insel inselBest, ArrayList<Bruecke> listBruecken) {
        System.out.println("prüfeKreuzungNord: InselNeu: " +inselNeu.getPosInselX() +", " + +inselNeu.getPosInselY() +" inselBest: "+inselBest.getPosInselX()+", " +inselBest.getPosInselY());
        int xNeu = inselNeu.posInselX;
        int yNeu = inselNeu.posInselY;
        //int xBest = inselBest.posInselX;
        int yBest = inselBest.posInselY;

        //Nord
        // gibts eine best Brücke, welche horizontal zwischen neuer und best Insel liegt
        //
        //  oneu
        //  |
        //o---o
        //  |
        //  obest
        if(listBruecken.isEmpty())
            return brueckeNichtKreuzNord=true;
        else if(inselNeu==null)
            return brueckeNichtKreuzNord=false;
        else {
            for(int b=0; b<listBruecken.size(); b++) {
                if((listBruecken.get(b).getStartInselx() < xNeu && listBruecken.get(b).getEndInselx() > xNeu  || listBruecken.get(b).getEndInselx() < xNeu && listBruecken.get(b).getStartInselx() > xNeu ) && listBruecken.get(b).getStartInsely() >= yNeu && listBruecken.get(b).getStartInsely() < yBest && listBruecken.get(b).getEndInsely()==listBruecken.get(b).getEndInsely()) {
                    brueckeNichtKreuzNord=false;
                    inselNeu=null;
                    System.gc();
                    //Generator.countAnzInsel--;
                    System.out.println("Insel kreuzt eine Brücke im Norden, Anz. Insel total " +Generator.countAnzInsel);
                    break;
                }
                else brueckeNichtKreuzNord=true;
            }
        }
        return brueckeNichtKreuzNord;
    }


    /**
     * Prüft, ob die neu gesetzte Insel in Rchtung Osten keine Brücke kreuzt.
     * Wenn die Brückenliste nicht leer ist und die Insel nicht null ist, wird die Brückenliste durchsucht.
     * Wenn die Insel eine Brücke kreuzt, wird die Insel wieder gelöscht.
     *
     *
     * @param inselNeu Die neue Insel
     * @param inselBest Die bestehende Insel
     * @param listBruecken Alle bereits gesetzten Brücken
     * @return false, wenn die gesetzte Insel im Osten eine Brücke kreuzt
     */
    private boolean pruefeKreuzungBrueckenOst(Insel inselNeu, Insel inselBest, ArrayList<Bruecke> listBruecken) {
        System.out.println("prüfeKreuzungOst: InselNeu: " +inselNeu.getPosInselX() +", " + +inselNeu.getPosInselY() +" inselBest: "+inselBest.getPosInselX()+", " +inselBest.getPosInselY());
        int xNeu = inselNeu.posInselX;
        int y = inselNeu.posInselY;
        int xBest = inselBest.posInselX;
        /*int yBest = inselBest.posInselY;*/

        //Ost
        // gibts eine best Brücke, welche vertikal zwischen neuer und best Insel liegt
        if(listBruecken.isEmpty())
            brueckeNichtKreuzOst=true;
        else if(inselNeu==null)
            return brueckeNichtKreuzOst=false;
        else {
            //for(Bruecke b:listBruecken) {
            for(int b=0; b<listBruecken.size(); b++) {
                //if(b.getStartInselx() < xNeu && b.getStartInselx() > xBest   && (b.getStartInsely() < y && b.getStartInsely() > y || b.getEndInsely() < y && b.getStartInsely() > y )) {
                if(listBruecken.get(b).getStartInselx() <= xNeu && listBruecken.get(b).getStartInselx() > xBest   && (listBruecken.get(b).getStartInsely() < y && listBruecken.get(b).getEndInsely() > y || listBruecken.get(b).getEndInsely() < y && listBruecken.get(b).getStartInsely() > y ) && listBruecken.get(b).getEndInselx()==listBruecken.get(b).getEndInselx()) {
                    brueckeNichtKreuzOst=false;
                    inselNeu=null;
                    System.gc();
                    //Generator.countAnzInsel--;
                    System.out.println("Insel kreuzt eine Brücke im Osten " +Generator.countAnzInsel);
                    break;
                }
                else brueckeNichtKreuzOst=true;
            }
        }
        return brueckeNichtKreuzOst;
    }

    /**
     *
     * Prüft, ob die neu gesetzte Insel in Rchtung Süden keine Brücke kreuzt.
     * Wenn die Brückenliste nicht leer ist und die Insel nicht null ist, wird die Brückenliste durchsucht.
     * Wenn die Insel eine Brücke kreuzt, wird die Insel wieder gelöscht.
     *
     *
     * @param inselNeu Die neue Insel
     * @param inselBest Die bestehende Insel
     * @param listBruecken Alle bereits gesetzten Brücken
     * @return false, wenn die gesetzte Insel im Süden eine Brücke kreuzt
     */
    private boolean pruefeKreuzungBrueckenSued(Insel inselNeu, Insel inselBest, ArrayList<Bruecke> listBruecken) {
        System.out.println("prüfeKreuzungSüd: InselNeu: " +inselNeu.getPosInselX() +", " + +inselNeu.getPosInselY() +" inselBest: "+inselBest.getPosInselX()+", " +inselBest.getPosInselY());
        int x = inselNeu.posInselX;
        int yNeu = inselNeu.posInselY;
        //int xBest = inselBest.posInselX;
        int yBest = inselBest.posInselY;

        //Sued
        if(listBruecken.isEmpty())
            brueckeNichtKreuzSued=true;
        else if(inselNeu==null)
            return brueckeNichtKreuzSued=false;
        else {
            for(int b=0; b<listBruecken.size(); b++) {
                if((listBruecken.get(b).getStartInselx() < x && listBruecken.get(b).getEndInselx() > x  || listBruecken.get(b).getEndInselx() < x && listBruecken.get(b).getStartInselx() > x ) && listBruecken.get(b).getStartInsely() <= yNeu && listBruecken.get(b).getStartInsely() > yBest && listBruecken.get(b).getEndInsely()==listBruecken.get(b).getEndInsely()) {
                    brueckeNichtKreuzSued=false;
                    inselNeu=null;
                    System.gc();
                    //Generator.countAnzInsel--;
                    System.out.println("Insel kreuzt eine Brücke im Süden " +Generator.countAnzInsel);
                    break;
                }
                else brueckeNichtKreuzSued=true;
            }
        }
        return brueckeNichtKreuzSued;
    }


    /**
     * Prüft, ob die neu gesetzte Insel in Rchtung Westen keine Brücke kreuzt.
     * Wenn die Brückenliste nicht leer ist und die Insel nicht null ist, wird die Brückenliste durchsucht.
     * Wenn die Insel eine Brücke kreuzt, wird die Insel wieder gelöscht.
     *
     *
     * @param inselNeu Die neue Insel
     * @param inselBest Die bestehende Insel
     * @param listBruecken Alle bereits gesetzten Brücken
     * @return false, wenn die gesetzte Insel im Westen eine Brücke kreuzt
     */

    private boolean pruefeKreuzungBrueckenWest(Insel inselNeu, Insel inselBest, ArrayList<Bruecke> listBruecken) {
        System.out.println("prüfeKreuzungWest: InselNeu: " +inselNeu.getPosInselX() +", " + +inselNeu.getPosInselY() +" inselBest: "+inselBest.getPosInselX()+", " +inselBest.getPosInselY());
        int xNeu = inselNeu.posInselX;
        int y = inselNeu.posInselY;
        int xBest = inselBest.posInselX;
        /*int yBest = inselBest.posInselY;*/

        //West
        // gibts eine best Brücke, welche vertikal zwischen neuer und best Insel liegt
        if(listBruecken.isEmpty())
            brueckeNichtKreuzWest=true;
        else if(inselNeu==null)
            return brueckeNichtKreuzWest=false;
        else {
            for(int b=0; b<listBruecken.size(); b++) {
                if(listBruecken.get(b).getStartInselx() >= xNeu && listBruecken.get(b).getStartInselx() < xBest   && (listBruecken.get(b).getStartInsely() < y && listBruecken.get(b).getEndInsely() > y || listBruecken.get(b).getEndInsely() < y && listBruecken.get(b).getStartInsely() > y ) && listBruecken.get(b).getEndInselx()==listBruecken.get(b).getEndInselx()) {
                    brueckeNichtKreuzWest=false;
                    inselNeu=null;
                    System.gc();
                    //Generator.countAnzInsel--;
                    System.out.println("Insel kreuzt eine Brücke im Westen " +Generator.countAnzInsel);
                    break;



                }
                else brueckeNichtKreuzWest=true;
            }
        }
        return brueckeNichtKreuzWest;
    }



    /*
    void pruefeAnzahlBruecken() {
        (anzahlBruecken<6 && bestInsel.anzahlBruecken<6)
    }*/





    /**
     * Prüft, ob die neu gesetzte Insel bereits existiert.
     *
     * @param inselPruefen Die neu gesetzte Insel
     * @param listInseln Die Gesamtinselliste
     * @return true, wenn die Insel nicht bereits existiert
     */

    // prüft, ob die Insel bereits existiert, indem sie die Liste durchläuft und auf Duplikate schaut
    private boolean pruefePositionBereitsVorhanden(Insel inselPruefen, ArrayList<Insel> listInseln) {

        for (int i = 0; i < listInseln.size(); i++) {
            //for (Insel ins : listInseln) {
            if (listInseln.get(i).equals(inselPruefen)) {
                isNotDoppelt = false;
                // inselPruefen=null;
                // System.gc();
                break;
            }
            else isNotDoppelt=true;
        }
        return isNotDoppelt;

    }

    /**
     *
     * Die neue Insel wird in die Gesamtinselliste und der Liste mit den wählbaren Insel eingefügt.
     *
     * @param setzendeInsel Die neue Insel
     * @param alleInseln Die Gesamtinselliste
     * @param reduzierteListe Die Liste mit den wählbaren Inseln
     */

    public void setzeInsel(Insel setzendeInsel, ArrayList<Insel> alleInseln, ArrayList<Insel>reduzierteListe) {
        alleInseln.add(setzendeInsel);
        reduzierteListe.add(setzendeInsel);
        System.out.println(setzendeInsel.getId() +" wurde der Liste "  +" wälbareInselListe hinzugefügt: " +reduzierteListe);
        System.out.println(setzendeInsel.getId() +" wurde der GesamtListe hinzugefügt: " +alleInseln);
        System.out.println( "Insel lösbar: " +setzendeInsel.isLoesbarN() +", " +setzendeInsel.isLoesbarO() +", " +setzendeInsel.isLoesbarS() +", " +setzendeInsel.isLoesbarW());
    }


    /**
     *
     * Bei der neu gesetzten Insel wird kontrolliert, ob von ihr aus weitere Brücken gezogen werden können.
     * Ist sie pro Richtung entweder mit einer Brücke verbunden, liegt sie neben einer Insel (Abstand <4: um Insel dazwischen
     * setzen),  liegt sie am Rand (Abstand <2: bei >=2 kann noch eine Insel gesetzt werden),
     * liegt sie neben einer Brücke (Abstand < 3: um eine Insel noch davor zu setzen).
     *  Wenn Insel nicht mehr verwendet werden kann, wird die Insel aus der Liste der wählbaren Inseln gelöscht
     *  und der Liste der nicht mehr wählbaren Inseln hinzugefügt.
     *
     *
     * @param inselNeu Die neue Insel, die gesetzt wurde
     * @param bestInsel Die bestehende Insel, von der aus die neue Insel gesetzt wurde
     * @param alleInseln Gesamtinselliste
     * @param waehlbareInsel Liste mit den wählbaren Inseln
     * @param nichtWaehlbareInseln Liste mit den nicht mehr wählbaren Inseln
     */

    private void pruefeInselWiederverwendenNeu(Insel inselNeu, ArrayList<Insel> alleInseln, ArrayList<Insel> waehlbareInsel, ArrayList<Insel> nichtWaehlbareInseln){


        // sind die Inseln schon mit einer Brücke verbunden?
        boolean nord=pruefeMitBrueckeVerbundenNord(inselNeu, alleInseln, bestBrueckeListe); //im Norden
        boolean ost=pruefeMitBrueckeVerbundenOst(inselNeu, alleInseln, bestBrueckeListe); // im Osten
        boolean sued =pruefeMitBrueckeVerbundenSued(inselNeu, alleInseln, bestBrueckeListe); // im Süden
        boolean west =pruefeMitBrueckeVerbundenWest(inselNeu, alleInseln, bestBrueckeListe); //im Westen

        // die nächsten Insel: wenn keine, dann null
        Insel nextInsNord= naechsteInselNord(inselNeu, alleInseln);
        Insel nextInsOst= naechsteInselOst(inselNeu, alleInseln);
        Insel nextInsSued= naechsteInselSued(inselNeu, alleInseln);
        Insel nextInsWest= naechsteInselWest(inselNeu, alleInseln);

        // Abstand bis nächste Insel, wenn keine dann Abstand bis Rand
        int inselAbstandNord = pruefeAbstandBisNaechsteInselNord(inselNeu, nextInsNord,alleInseln);
        int inselAbstandOst = pruefeAbstandBisNaechsteInselOst(inselNeu, nextInsOst,alleInseln);
        int inselAbstandSued = pruefeAbstandBisNaechsteInselSued(inselNeu, nextInsSued,alleInseln);
        int inselAbstandWest = pruefeAbstandBisNaechsteInselWest(inselNeu, nextInsWest,alleInseln);

        // wie gross ist der Abstand bis zum Rand?
        int nordAbst = inselNeu.getPosInselY();
        int ostAbst = (Generator.breite -1) -inselNeu.getPosInselX();
        int suedAbst = (Generator.hoehe -1) - inselNeu.getPosInselY();
        int westAbst = inselNeu.getPosInselX();

        //Abstand bis zur nächsten gekreuzte Brücke, wenn keine Abstand bis Rand
        int nordBruecke= pruefeAbstandBisNaechsteBrueckeNord(inselNeu, bestBrueckeListe);
        int ostBruecke= pruefeAbstandBisNaechsteBrueckeOst(inselNeu, bestBrueckeListe);
        int suedBruecke= pruefeAbstandBisNaechsteBrueckeSued(inselNeu, bestBrueckeListe);
        int westBruecke= pruefeAbstandBisNaechsteBrueckeWest(inselNeu, bestBrueckeListe);
     
        if((nord==true || nordAbst< 2 || (nordBruecke<3 && nextInsNord != null)) || (inselAbstandNord<3 && nextInsNord != null) || (nordBruecke<2 && nextInsNord == null))
                inselNeu.setLoesbarN(false);
        if((ost==true || ostAbst<2  || (ostBruecke<3 &&  nextInsOst != null)) || (inselAbstandOst<3 && nextInsOst != null) || (ostBruecke<2 &&  nextInsOst == null))
                    inselNeu.setLoesbarO(false);
        if((sued==true || suedAbst<2  || (suedBruecke<3 && nextInsSued != null)) || (inselAbstandSued<3 && nextInsSued != null) || (suedBruecke<2 && nextInsSued == null))
                    inselNeu.setLoesbarS(false);
        if((west==true || westAbst<2  || (westBruecke<3 && nextInsWest != null)) || (inselAbstandWest<3 && nextInsWest != null) || (westBruecke<2 && nextInsWest == null))
                        inselNeu.setLoesbarW(false);


        // keine Brücke, Insel liegt nicht am Rand, Abstand zur nächsten Insel ist für eine weitere Insel genügend gross
        //(wenn eine Insel vorhanden ist und der Abstand zur nächsten Brücke ist für eine weiter Insel genügend gross
        if( inselNeu.isLoesbarN()==false && inselNeu.isLoesbarO() ==false && inselNeu.isLoesbarS()==false && inselNeu.isLoesbarW()==false )
            {
            nichtWaehlbareInseln.add(inselNeu);
            waehlbareInsel.remove(inselNeu);
            System.out.println(inselNeu.getId() +" kann nicht mehr verwendet werden");
            System.out.println(inselNeu.getId() +" wird aus wählbareInselnListe entfernt");
            System.out.println(inselNeu.getId() +" wurde der Liste nichtWälbareInselListe hinzugefügt");
        }

    }

    /**
     * Bei der bestehenden Insel wird kontrolliert, ob von ihr aus weitere Brücken gezogen werden können.
     * Ist sie pro Richtung entweder mit einer Brücke verbunden, liegt sie am Rand (Abstand <2: bei >2 kann noch eine Insel gesetzt werden)
     * oder liegt sie neben einer Brücke (Abstand < 3: um eine Insel noch davor zu setzen).
     *  Wenn Insel nicht mehr verwendet werden kann, wird die Insel aus der Liste der wählbaren Inseln gelöscht
     *  und der Liste der nicht mehr wählbaren Inseln hinzugefügt.
     *
     *
     * @param inselNeu Die neue Insel, die gesetzt wurde
     * @param bestInsel Die bestehende Insel, von der aus die neue Insel gesetzt wurde
     * @param alleInseln Gesamtinselliste
     * @param waehlbareInsel Liste mit den wählbaren Inseln
     * @param nichtWaehlbareInseln Liste mit den nicht mehr wählbaren Inseln
     */
    private void pruefeInselWiederverwendenBest( Insel bestInsel, ArrayList<Insel> alleInseln, ArrayList<Insel> waehlbareInsel, ArrayList<Insel> nichtWaehlbareInseln){
        /*int nordAbst;
        int ostAbst;
        int suedAbst;
        int westAbst;
         */

        // ist die neue Insel jetzt auf allen Seiten mit einer Brücke verbunden?
        boolean nord=pruefeMitBrueckeVerbundenNord(bestInsel, alleInseln, bestBrueckeListe); //im Norden
        boolean ost=pruefeMitBrueckeVerbundenOst(bestInsel, alleInseln, bestBrueckeListe); // im Osten
        boolean sued =pruefeMitBrueckeVerbundenSued(bestInsel, alleInseln, bestBrueckeListe); // im Süden
        boolean west =pruefeMitBrueckeVerbundenWest(bestInsel, alleInseln, bestBrueckeListe); //im Westen


        //Abstand bis zur nächsten Brücke
        int nordBruecke= pruefeAbstandBisNaechsteBrueckeNord(bestInsel, bestBrueckeListe);
        int ostBruecke= pruefeAbstandBisNaechsteBrueckeOst(bestInsel, bestBrueckeListe);
        int suedBruecke= pruefeAbstandBisNaechsteBrueckeSued(bestInsel, bestBrueckeListe);
        int westBruecke= pruefeAbstandBisNaechsteBrueckeWest(bestInsel, bestBrueckeListe);

        if(nord==true || maxNord< 2 || (nordBruecke <2 && maxNord==2)  || (nordBruecke<3 && nextInselNord !=null && maxNord<2)) //|| (nordBruecke <3 && maxNord<2)
            bestInsel.setLoesbarN(false);
        if(ost==true || maxOst<2 || (ostBruecke <2 && maxOst==2 )  || (ostBruecke<3 && nextInselOst != null && maxOst<2))  // || (ostBruecke <2 && maxOst<2)
            bestInsel.setLoesbarO(false);
        if(sued==true || maxSued<2 || (suedBruecke <2 && maxSued ==2)  || (suedBruecke<3 && nextInselSued != null && maxSued <2))  // || (suedBruecke <2 && maxSued <2)
            bestInsel.setLoesbarS(false);
        if(west==true || maxWest<2 || (westBruecke <2 && maxWest ==2)  ||( westBruecke<3 && nextInselWest != null && maxWest<2))  // || (westBruecke <2 && maxWest <2)
            bestInsel.setLoesbarW(false);

        if((bestInsel.isLoesbarN()==false) && ( bestInsel.isLoesbarO()==false) && ( bestInsel.isLoesbarS()==false) && ( bestInsel.isLoesbarW()==false)) {
            nichtWaehlbareInseln.add(bestInsel);
            waehlbareInsel.remove(bestInsel);
            System.out.println(bestInsel.getId() +" wird aus wählbareInselnListe entfernt");
            System.out.println(bestInsel.getId() +" wurde der Liste nichtWälbareInselListe hinzugefügt");
        }

    }




    @Override
    public boolean equals(Object obj) {
        if (obj == this) return true;
        if (obj == null) return false;

        if (obj.getClass() != getClass()) return false;

        Insel i = (Insel) obj;
        return (i.posInselX == posInselX) && (i.posInselY == posInselY);

    }

    public int getPosInselX() {
        return posInselX;
    }

    public int getPosInselY() {
        return posInselY;
    }

    public void setPosInselX(int posInselX) {
        this.posInselX = posInselX;
    }

    public void setPosInselY(int posInselY) {
        this.posInselY = posInselY;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getAnzBruecken() {
        return anzahlBruecken;
    }

    public void setAnzBrueckenNeu(int anzBruecken) {
        this.anzahlBruecken = anzBruecken;
    }


    public boolean isLoesbarN() {
        return loesbarN;
    }


    public boolean isLoesbarO() {
        return loesbarO;
    }


    public boolean isLoesbarS() {
        return loesbarS;
    }


    public boolean isLoesbarW() {
        return loesbarW;
    }


    public void setLoesbarN(boolean loesbarN) {
        this.loesbarN = loesbarN;
    }


    public void setLoesbarO(boolean loesbarO) {
        this.loesbarO = loesbarO;
    }


    public void setLoesbarS(boolean loesbarS) {
        this.loesbarS = loesbarS;
    }


    public void setLoesbarW(boolean loesbarW) {
        this.loesbarW = loesbarW;
    }
 
 
 
    @Override
    public int compareTo(Insel insel)
    {
        if (getPosInselX() != insel.getPosInselX() ) {
            return getPosInselX() - insel.getPosInselX();
        }
        else if (getPosInselY() != insel.getPosInselY() ) {
            return getPosInselY() - insel.getPosInselY();
        }
        else
            return 0;
     
     
    }
 

}

 

[JCODA]

Jetzt fehlt wohl noch RaetselDialog und Parser.
Das nächste Mal würde ich auch ein ZIP nehmen

 

[Josie]

Wäre vielleicht einfacher, ja..

Ok, hier noch RatselDialog

package gui;

import java.awt.*;
import java.awt.event.*;
import java.util.Random;
import java.util.regex.Pattern;

import javax.swing.*;
import javax.swing.border.EmptyBorder;

public class RaetselDialog extends JDialog implements ActionListener, ItemListener {

    Random r =new Random();

    JButton abbrechenButton = new JButton("Abbrechen");
    JButton okButton = new JButton("OK");
    JTextField textFBreite = new JTextField(10);
    JTextField textFHoehe = new JTextField(10);
    JTextField textFInsel = new JTextField(10);
    JRadioButton rButtonAutom;
    JRadioButton rButtonWaehlen;

    // um das Ergebnis speichern
    public String breite = "";
    public String hoehe = "";
    public String insel = "";

    JCheckBox checkboxInsel;
    private int br;
    private int h;
    private int minInsel;
    int maxInsel;
    int ins;

    public boolean okGedrueckt = false;


    public RaetselDialog(JFrame f) {

        super(f, "Neues Rätsel", true); //modales Dialogfenster
        setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        // Beobachter registrieren
        okButton.addActionListener(this);
        abbrechenButton.addActionListener(this);

        JPanel contentPanel = new JPanel(new BorderLayout());
        // contentPanel.setBorder(new EmptyBorder(5, 5, 5, 5));

        // NORTH
        JPanel radioPanel = new JPanel(new GridLayout(2, 1));
        rButtonAutom = new JRadioButton(
                "Automatische Grösse und Inselanzahl");
        rButtonAutom.addActionListener(this); // ActionListener registrieren
        rButtonWaehlen = new JRadioButton(
                "Grösse und/oder Inselanzahl festlegen");
        rButtonWaehlen.addActionListener(this); //ActionListener registrieren
        radioPanel.add(rButtonAutom);
        radioPanel.add(rButtonWaehlen);
        add(radioPanel, BorderLayout.NORTH);

        // CENTER
        JPanel centerPanel = new JPanel(new GridLayout(2, 1));

        JPanel groessePanel = new JPanel(new GridLayout(4, 2));
        groessePanel.setAlignmentY(JComponent.LEFT_ALIGNMENT);
        JLabel labelBreite = new JLabel("Breite", JLabel.RIGHT);
        JLabel labelHoehe = new JLabel("Höhe", JLabel.RIGHT);
        checkboxInsel = new JCheckBox("Inselanzahl festlegen:");
        checkboxInsel.addItemListener(this);   // checkbox registrieren

        groessePanel.add(labelBreite);
        groessePanel.add(textFBreite);
        groessePanel.add(labelHoehe);
        groessePanel.add(textFHoehe);
        groessePanel.add(checkboxInsel);

        JPanel inselPanel = new JPanel(new FlowLayout(FlowLayout.RIGHT));
        JLabel labelInsel = new JLabel("Inseln");
        inselPanel.add(labelInsel);
        inselPanel.add(textFInsel);

        centerPanel.add(groessePanel);
        centerPanel.add(inselPanel);
        add(centerPanel, BorderLayout.CENTER);

        // SOUTH
        JPanel southPanel = new JPanel(new FlowLayout(FlowLayout.CENTER));
        southPanel.add(abbrechenButton);
        southPanel.add(okButton);
        add(southPanel, BorderLayout.SOUTH);

        pack();

    }

    public void showDialog() {
        textFBreite.setText("");
        textFHoehe.setText("");
        textFInsel.setText("");
        breite = "";
        hoehe ="";
        insel  = "";
        textFInsel.setEnabled(false);
        checkboxInsel.setSelected(false);
        rButtonWaehlen.setSelected(true);
        rButtonAutom.setSelected(false);
        textFBreite.setEnabled(true);
        textFHoehe.setEnabled(true);
        okGedrueckt=false;
        setVisible(true);
       
    }



    @Override
    public void actionPerformed(ActionEvent e) {
        Object source = e.getSource();

        // Breite, Höhe, Inselzahl zufällig wählen
        if (source == rButtonAutom) {

            rButtonWaehlen.setSelected(false);
            textFBreite.setEnabled(false);
            textFHoehe.setEnabled(false);

            br=r.nextInt(25-2 + 1) +2;
            breite = Integer.toString(br);
            h=r.nextInt(25-2 + 1) +2;
            hoehe=Integer.toString(h);
            // Minimumanzahl der Inseln bestimmen
            minInsel= Math.min(br,h);
            // Maximumanzahl der Inseln berechnen
            maxInsel=br*h/5;
            // Inselzahl zwischen Minimum und Maximum wählen
            ins=r.nextInt(maxInsel-minInsel+1)+minInsel;

            insel=Integer.toString(ins);
            textFBreite.setText(breite);
            textFHoehe.setText(hoehe);
            textFInsel.setText(insel);
        }

        // Übernahme der Zahlen nach "OK" drücken
        if (source == okButton) {
            okGedrueckt=true;
            breite=textFBreite.getText();
            hoehe = textFHoehe.getText();


            // wenn man Inselanzahl zufällig berechnen möchte
            if(!checkboxInsel.isSelected() && textFInsel.getText().isEmpty()) {
                br = Integer.parseInt(textFBreite.getText());
                h = Integer.parseInt(textFHoehe.getText());

                // Minimum
                minInsel= Math.min(br,h);
                // Maximum
                maxInsel=br*h/5;
                // Zahl zwischen min und max
                ins=r.nextInt(maxInsel-minInsel+1)+minInsel;

                insel=Integer.toString(ins);
                textFInsel.setText(insel);
            }else insel = textFInsel.getText();

            // Kontrolle, ob Inselanzahl zwischen min und max liegt
            if(!textFBreite.getText().isEmpty() && !textFHoehe.getText().isEmpty() && !textFInsel.getText().isEmpty()) {
                br=Integer.parseInt(breite);
                h=Integer.parseInt(hoehe);
                ins=Integer.parseInt(insel);
                minInsel= Math.min(br,h);
                maxInsel=br*h/5;

                if(ins<minInsel || ins > maxInsel) {
                    JOptionPane.showMessageDialog(null, "Sie müssen eine Inselanzahl zwischen " +minInsel +" und " +maxInsel +" wählen.");
                    return;

                }

                setVisible(false);
            }

        }   
        else if (source == abbrechenButton) {
            setVisible(false);
            return;
        }

        if (source == rButtonWaehlen) {
            //rButtonWaehlen.setSelected(true);
            rButtonAutom.setSelected(false);
            textFBreite.setEnabled(true);
            textFHoehe.setEnabled(true);
            textFInsel.setEnabled(false);

        }


    }

// was tun, wenn Checkbox ausgewählt wird
    @Override
    public void itemStateChanged(ItemEvent ie) {
        Object sourceItem=ie.getItemSelectable();
        if(sourceItem==checkboxInsel) {
            textFInsel.setEnabled(true);


            if(checkboxInsel.isSelected())
                textFInsel.setEnabled(true);
            else
                textFInsel.setEnabled(false);
        }
    }


   
   
   
   
            public void setBreite(String breite) {
                this.breite = breite;
            }

            public void setHoehe(String hoehe) {
                this.hoehe = hoehe;
            }

            public void setInsel(String insel) {
                this.insel = insel;
            }

            public String getBreite() {

                return breite;
            }

            public String getHoehe() {

                return hoehe;
            }

            public String getInsel() {
                return insel;
            }

   
}

und Parser :

package rechner;

import java.io.*;
import java.util.*;
import java.util.regex.Pattern;

import javax.swing.JOptionPane;

import root.*;

public class Parser {


    Spielfeld spielfeld;

    // Einlesen
    private List<String> zeilenEinlesen=new ArrayList<>(); //Liste für eingelesenen Zeilen

    private ArrayList<Insel> inselListeP = new ArrayList<>(); //Insel-Liste
    private ArrayList<Insel> inselListeErsatz = new ArrayList<>(); //Insel-Liste Ersatz
    private ArrayList<Bruecke> listBrueckenP = new ArrayList<>(); // Brücken-Liste

    // Schreiben
    private ArrayList<Insel> inselListePSortiert = new ArrayList<>();
    private ArrayList<Bruecke> listBrueckenPSortiert = new ArrayList<>();
    /*String[] feldString; //= new String[7];
    String[] inselString;
    String[] brueckeString;//= new String[7];
     */


    ArrayList<String> feldListeSchreiben = new ArrayList<String>();
    ArrayList<String>inselListePSchreiben = new ArrayList<String>();;
    ArrayList<String>brueckeListeSchreiben = new ArrayList<String>();;





    //Regexausdrücke
    String zahlen = "[0-9]+"; //"\\d+";
    String boolBruecken = "true|false";
    String field = "FIELD";
    String islands = "ISLANDS";
    String bridges = "BRIDGES";

    int countAnzInsel=0; //zählt Anzahl Insel hoch

    String pfad; //=BridgesMainGui.path;
   
    int start;
    int end;
    int x;
    int y;


    // Konstruktor zum Einlesen einer Datei (Öffnen)
    public Parser(String pfad) {
        this.pfad=pfad;
        einlesen();
        verarbeiten();
    }

    // Konstruktor zum Schreiben einer Datei (Speichern)
    public Parser(String pfad, ArrayList<Insel> inselListeP, ArrayList<Bruecke> listBrueckenP) {
        this.pfad=pfad;
        this.inselListeP=inselListeP;
        this.listBrueckenP=listBrueckenP;

        listenSortieren();
        bearbeiten();
        schreiben();
    }


    //////////////////// Datei einlesen ////////////////////////////////////////////////////////////

    /**
     * Die eingelesenen zeilenEinlesen für Feld werden hier verarbeitet. Die erste Zahl ist Breite, die zweite Zahl ist
     * Höhe und die dritte Zahl ist die Inselanzahl.
     *
     * @param zeile
     */
    private void feldLesen(String zeile) {
        String[] feldString = zeile.split("[\\s\\.x,;!?\\[\\] \\(\\) \\|]+"); //("\\s");
        Integer br=null;
        Integer h=null;
        Integer maxIns=null;

        // Array durchlaufen und jede Zahl rausschreiben
        for(int z=0; z<feldString.length; z++) {

            if(Pattern.matches(zahlen, feldString[z])) {
                if(br==null) { // für die erste Zahl der Zeile
                    br=Integer.parseInt(feldString[z]);
                    Generator.breite=br.intValue();
                    continue;
                }
                if(br!=null && h==null) { //für die zweite Zahl der Zeile
                    h=Integer.parseInt(feldString[z]);
                    Generator.hoehe=h.intValue();
                    continue;
                }
                if(br!=null && h!=null && maxIns==null) { // für die dritte Zahl der Zeile
                    maxIns=Integer.parseInt(feldString[z]);
                    Generator.maximum=maxIns.intValue();
                    //System.out.println("Breite: " +Generator.breite);
                    //System.out.println("Höhe: " +Generator.hoehe);
                    //System.out.println("Inseln: " +Generator.maximum);
                    continue;
                }


            }

        }

    }


    /**
     * Die eingelesenen zeilenEinlesen für die Insel werden hier verarbeitet. Die erste Zahl ist der x-Wert, die zweite Zahl ist
     * der y-Wert und die dritte Zahl ist die Brückenanzahl. Die Insel wird in die "inselListeP" eingetragen.
     *
     * @param zeile
     */

    private void inselLesen(String zeile) {
        String[] inselString = zeile.split("[\\s\\.x,;!?\\[\\] \\(\\) \\|]+"); //("\\s");

        Integer posInselX=null;
        Integer posInselY=null;
        Integer anzBruecken=null;

        x=0;
        y=0;
        int anzBr=0;



        for(int z=0; z<inselString.length; z++) {

            if(Pattern.matches(zahlen, inselString[z])) {


                if(posInselX==null) { // die erste Zahl der Zeile
                    posInselX=Integer.parseInt(inselString[z]);
                    x= posInselX.intValue();
                    continue;
                }
                if(posInselX!=null && posInselY==null) { // die zweite Zahl der Zeile
                    posInselY=Integer.parseInt(inselString[z]);
                    y=posInselY.intValue();
                    continue;
                }
                if(posInselX!=null && posInselY!=null && anzBruecken==null) { // die dritte Zahl der Zeile
                    anzBruecken=Integer.parseInt(inselString[z]);
                    anzBr= anzBruecken.intValue();

                    Insel insel = new Insel(x, y, inselListeP, countAnzInsel, anzBr, true, true, true, true);
                    insel.setzeInsel(insel, inselListeP, inselListeErsatz);
                    //System.out.println("Insel: x" +posInselX +" y " +posInselY +" id " +countAnzInsel +" anzBrücken " +anzBruecken);
                    countAnzInsel++;

                    continue;
                }


            }


        }
    }


    /**
     * Die eingelesenen zeilenEinlesen für die Brücken werden hier verarbeitet. Die erste Zahl ist die Start-Insel, die zweite Zahl ist
     * die End-Insel und die dritte Zahl gibt an, ob es eine Doppel-Brücke ist. Die Brücke wird in die "listBrueckenP" eingetragen.
     *
     * @param zeile
     */

    private void brueckeLesen(String zeile) {
        String[] brueckeString = zeile.split("[\\s\\.x,;!?\\[\\] \\(\\) \\|]+"); //("\\s");

        Integer idStart=null;
        Integer idEnd=null;
        Boolean doppelt =null;
        start=0;
        end=0;
        boolean dopp=false;

       
        for(int z=0; z<brueckeString.length; z++) {

            if(Pattern.matches(zahlen, brueckeString[z])) {

                if(idStart==null) {  // die erste Zahl der Zeile
                    idStart=Integer.parseInt(brueckeString[z]);
                    start= idStart.intValue();
                    continue;
                }
                if(idStart!=null && idEnd==null) {  // die zweite Zahl der Zeile
                    idEnd=Integer.parseInt(brueckeString[z]);
                    end=idEnd.intValue();
                    continue;
                }


                // für Auswertung der Doppel-Brücke
            }else if(Pattern.matches(boolBruecken, brueckeString[z])) {
                if(idStart!=null && idEnd!=0 && doppelt==null) {
                    doppelt=Boolean.parseBoolean(brueckeString[z]);
                    dopp= doppelt.booleanValue();
                    Bruecke bruecke = new Bruecke(start, end, listBrueckenP, 0, 0, 0, 0, dopp);
                    bruecke.setzeBruecke(bruecke, listBrueckenP);
                    //System.out.println("Bruecke: start: " +idStart +" end: " +idEnd +" doppelt: " +doppelt);
                    continue;
                }
            }



        }
    }



    /**
     * Der Pfad der ausgewählten Datei wird übergegeben und zeilenEinlesenweise eingelesen und gleichzeitig leere zeilenEinlesen übersprungen.
     * Die zeilenEinlesen werden in eine Liste gespeichert.
     * Bei Fehlermeldungen erschein ein Dialogfenster.
     */

    void einlesen() {
       
        String zeile;

        try {

            BufferedReader reader = new BufferedReader(new FileReader(pfad));

            while((zeile = reader.readLine()) != null) {
                if (zeile.length() ==0) continue;
                if (zeile.charAt(0) == '[' ) continue;
                if (zeile.charAt(0) == ']') continue;
                if (zeile.charAt(0) == '#') continue;
                zeilenEinlesen.add(zeile);
            }


            reader.close();


        } catch (FileNotFoundException e) {
            //e.printStackTrace();
            JOptionPane.showMessageDialog(null, "Datei nicht gefunden!");
        } catch (IOException e) {
            //e.printStackTrace();
            JOptionPane.showMessageDialog(null, "Fehler beim Einlesen der Datei");
        }

    }


    /**
     * Die Liste mit den eingelesenen zeilenEinlesen wird durchlaufen.
     */
    void verarbeiten() {

        while(zeilenEinlesen.size()>0) {
            if(Pattern.matches(field, zeilenEinlesen.get(0))) {
                zeilenEinlesen.remove(zeilenEinlesen.get(0));
                while(Pattern.matches(islands, zeilenEinlesen.get(0))==false) {
                    feldLesen(zeilenEinlesen.get(0));
                    zeilenEinlesen.remove(zeilenEinlesen.get(0));
                } if ( zeilenEinlesen.size()==0)
                     JOptionPane.showMessageDialog(null, "Rätsel enthält Fehler, kann nicht geladen werden. \n"
                            + "Bitte wählen Sie ein anderes Rätsel");

            }
            else if(Pattern.matches(islands, zeilenEinlesen.get(0))) {
                zeilenEinlesen.remove(zeilenEinlesen.get(0));
                while(Pattern.matches(bridges, zeilenEinlesen.get(0))==false) {
                    inselLesen(zeilenEinlesen.get(0));
                    zeilenEinlesen.remove(zeilenEinlesen.get(0));
                } if ( zeilenEinlesen.size()==0)
                     JOptionPane.showMessageDialog(null, "Rätsel enthält Fehler, kann nicht geladen werden. \n"
                            + "Bitte wählen Sie ein anderes Rätsel");

            }
            else if(Pattern.matches(bridges, zeilenEinlesen.get(0))) {
                zeilenEinlesen.remove(zeilenEinlesen.get(0));
                while(zeilenEinlesen.size()>0) {
                    brueckeLesen(zeilenEinlesen.get(0));
                    zeilenEinlesen.remove(zeilenEinlesen.get(0));
                }

            }

        } //////////////// hier Spiel ausführen///////////
        if(Generator.maximum>(countAnzInsel) || Generator.maximum<(countAnzInsel) ||
               start > Generator.maximum || end > Generator.maximum || x > Generator.breite || y> Generator.hoehe) {
            JOptionPane.showMessageDialog(null, "Rätsel enthält Fehler, kann nicht geladen werden. \n"
                    + "Bitte wählen Sie ein anderes Rätsel");
        }
    }




    ///////// Datei schreiben ///////////////////////////////////////////////////

/**
* Die Listen werden sortiert: Die Insel-Liste zuerst nach x-, dann nach y-Werten.
* Die Brücken-Liste zuerst nach dem Start-Index und danach nach dem End-Index
*/
   
    void listenSortieren() {

      

        inselListePSortiert=inselListeP;
        Collections.sort(inselListePSortiert);

        listBrueckenPSortiert=listBrueckenP;
        Collections.sort(listBrueckenPSortiert);
/*
        for(Insel ins:inselListePSortiert)
            System.out.println(ins.getPosInselX() +", " +ins.getPosInselY());
        for(Bruecke br:listBrueckenPSortiert)
            System.out.println(br.getStartInselID() +", " +br.getEndInselID());
*/
    }

/**
* Hier werden die einzelnen Bearbeitungsschritten ausgeführt.
*/
    void bearbeiten() {
        feldSchreiben();
        inselSchreiben();
        brueckeSchreiben();

    }

/**
* Die Datei wird geschrieben und im übergebenen Pfad gespeichert.
*/
  
    void schreiben() {
        try {
            BufferedWriter writer = new BufferedWriter(new FileWriter(pfad));

            // Bereich "FIELD"
            writer.write(field);
            writer.newLine();
            for(String feldstr:feldListeSchreiben) {
                writer.write(feldstr);
            }
           
            // Bereich "ISLANDS"
            writer.newLine();
            writer.write(islands);

            for(int iz=0; iz<inselListePSchreiben.size(); iz++) {
                writer.newLine();
                writer.write(inselListePSchreiben.get(iz));

            }
           
            // Bereich "BRIDGES"
            writer.newLine();
            writer.write(bridges);

            for(int iz=0; iz<brueckeListeSchreiben.size(); iz++) {
                writer.newLine();
                writer.write(brueckeListeSchreiben.get(iz));

            }




            writer.close();


        } catch (FileNotFoundException e) {
            //e.printStackTrace();
            JOptionPane.showMessageDialog(null, "Datei nicht gefunden!");
        } catch (IOException e) {
            //e.printStackTrace();
            JOptionPane.showMessageDialog(null, "Fehler beim Schreiben der Datei");
        }

    }


    /**
     * Das Feld wird mit den Zeichen in eine Liste geschrieben.
     */

    void feldSchreiben() {

        String brSchr=String.valueOf(Generator.breite);
        String hSchr=String.valueOf(Generator.hoehe);
        String maxInselSchr=String.valueOf(Generator.maximum);

        // Zusammenfügen der einzelnen Zeichen
        String feldString = brSchr +"x" +hSchr +"|" +maxInselSchr;
        feldListeSchreiben.add(feldString);
       
    }

/**
* Die Inseln werden mit den Zeichen in eine Liste geschrieben. Pro String ein Listenelement.
*/
   
    void inselSchreiben() {
       
        inselListePSchreiben = new ArrayList<String>();
       
        for(Insel i: inselListePSortiert) {
            String posX= String.valueOf(i.getPosInselX());
            String posY= String.valueOf(i.getPosInselY());
            String anzBr= String.valueOf(i.getAnzBruecken());

         // Zusammenfügen der einzelnen Zeichen
            String inselString= "(" +posX +"," +posY +"|" +anzBr +")";
            inselListePSchreiben.add(inselString);
           
        }
    }

/**
* Die Brücken werden mit den Zeichen in eine Liste geschrieben. Pro String ein Listenelement.
*/
   
    void brueckeSchreiben()
    {
        brueckeListeSchreiben = new ArrayList<String>();

        for(Bruecke b: listBrueckenPSortiert) {

            String startID= String.valueOf(b.getStartInselID());
            String endID= String.valueOf(b.getStartInselID());
            String doppel = String.valueOf(b.isDoppelbruecke());

         // Zusammenfügen der einzelnen Zeichen
            String brueckeString= "(" +startID +"," +endID +"|" +doppel +")";
            brueckeListeSchreiben.add(brueckeString);

           
        }

    }





    public ArrayList<Insel> getinselListeP() {
        return inselListeP;
    }


    public ArrayList<Bruecke> getlistBrueckenP() {
        return listBrueckenP;
    }


    public void setinselListeP(ArrayList<Insel> inselListeP) {
        this.inselListeP = inselListeP;
    }


    public void setlistBrueckenP(ArrayList<Bruecke> listBrueckenP) {
        this.listBrueckenP = listBrueckenP;
    }


  

}

 

[JCODA]

Ich hab versucht mich da durchzuwühlen, aber es ist verdammt schwer, da durchzublicken. Vielleicht weil es so gut wie keine lokalen Variablen gibt und alles durcheinander ist...
Was steht denn in dem int-Array Spielfeld drin? oder was soll da drinstehen? Bei mir ist das immer 0.
Ich hab das Gefühl du hast sooo viel Code geschrieben, den man viel einfacher und lesbarer schreiben könnte.

Was mir aufgefallen ist, du hast super.paintComonent(g) auskommentiert. Das sollte wohl eher nicht auskommentiert sein.
Bei mir kommen sehr viele NullPointer je nachdem wie man auf die Inseln klickt. Da würde ich noch ein paar Null-Checks einführen bzw erstmal feststellen, warum diese auftreten.

Ich würde zunächst versuchen ohne translate() klar zu kommen, du kannst ja ein offset manuell an die gezeichneten Dinge setzen.

Da du deine Matrikelnummer angegeben hast ist das wohl für die Uni? Wie gut muss da bei euch die CodeQualität sein? Bisher scheint's dir hauptsächlich darum zu gehen, dass es funktioniert.

EDIT1: Was ich noch sagen wollte: Deine Insel-Klasse hat über 2200 (!) Zeilen. Normalerweise versucht man kleine Klassen (und Methoden!) zu haben, damit man sich immer nur auf ein Teilproblem konzentrieren kann.

EDIT2: Und was mir jetzt noch aufgefallen ist, du erzeugst mehrere Spielfelder? einmal im Generator und im MainGui, wenn du "new Spielfeld" aufrufst hast du tatsächlich ein neues Spielfeld.

 

[Josie]

Danke erstmals, dass du das alles angeschaut hast.
Ich bin totale Anfängerin, und ich weiss, dass vieles wahrscheinlich überflüssig ist und es besser machen kann (muss).
Ja, eine Uni-Aufgabe. Wie die Qualität sein muss, weiss ich auch nicht. Es ist eigentlich die erste grosse Aufgabe nach der Theorie. Zurzeit kann ich es noch nicht besser. Ich gebe mir Mühe, aber es ist Vieles neu für mich. Wie sie es dann bewerten, werde ich sehen.

Ja, die NullPointer gibt es, weil ich die Positionen der Nachbarinsel "berechne", aber wenn ich natürlich keine Insel treffe, gibts Fehler. Ich weiss, hier kommt dann noch eine Korrektur.

Ich habe ein translate() reingesetzt, damit die Inseln an der 0-Reihe nicht abgeschnitten sind. Und mit translate() hat das super funktioniert. Wie meinst du "offset manuell"? Also, meinst du einfach den Abstand zum Rand manuell setzen? Habe ich glaube ich schon versucht und habs nicht hingekriegt, deshalb translate().

Wegen new Spielfeld: Das habe ich zweimal. Einmal wenn ein Rätsel neu generiert wird (Generator) und einmal, wenn ein Rätsel geladen wird (vom Parser -> MainGui). Ziel ist ja, dass man dann auf dem Spielfeld das Rätsel lösen kann.

 

[Josie]

P.S.
Eigentlich sollte das Spielfeld zentriert sein.
Zuerst habe ich es mit (getWidth bzw.getHigh - breite) /2 versucht. Hat irgendwie nicht richtig mit der Darstellung finktioniert und bin deshalb auf einen festen Randabstand ausgewichen.
Vielleicht kannst du mir dazu noch einen Tipp geben, wie ich das richtig hinkriege...

 

[Josie]

PPS
Du hast ja noch gefragt wegen dem int Array Spielfeld. Ursprünglich habe ich gedacht ich initialisiere das Array zuerst alles mit 0 und wenn eine Insel gesetzt wird, steht dann dort eine 1. Und dann soll dort, wo eine 1 steht eine Insel gezeichnet werden. Aber ich habe das nun anders gelöst. Ich denke, diese Initialisierung kann ich nun löschen...