Repaint() in der Schleife funktioniert nicht immer

Salmo Salar

Mitglied
Hallo,
Nachdem mir bei meinem Projekt "Game of Life" schon neulich hier geholfen wurde, bin ich wieder steckengeblieben.
Wenn ich in BlueJ die main()-Methode in der Klasse Logik aufrufe, die die Methode spielen() aufruft, dann läuft das Programm wie es sollte - nach jeder Veränderung des Spielfeldes wird das Spielfeld neu gezeichnet. d.h. man sieht jeden Schritt.
Wenn ich aber erstmal nur die Klasse Logik erzeuge und dann den Button start drücke, registriert dies mein Listener (der in einer separaten Klasse liegt) und ruft ebenfalls die Methode spielen() auf, aber dann wird das Spielfeld erst angezeigt, wenn die Schleife in der Methode spielen() durchgelaufen ist, also nur das Endbild, in meinem Beispiel hier nach 10 Schritten.
Hier ist mein Code, etwas gekürzt:

Klasse Logik, die Hauptklasse:
Java:
import javax.swing.JFrame;
import javax.swing.JButton;
import java.util.Random;
import java.awt.BorderLayout;
import java.awt.FlowLayout;
import javax.swing.JPanel;

public class Logik
{
    private JFrame frame;
    private Welt welt = new Welt();
    public static void main(String args[]) throws InterruptedException {
        new Logik().spielen(50, 1000);
    }

    public Logik()
    {
        frame = new JFrame("Game of Life");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(515, 580);

        Listener audi = new Listener();
        audi.setLogik(this);
        JPanel panel = new JPanel();
        panel.setLayout(new BorderLayout());

        welt.addMouseListener(audi);
        panel.add(welt,BorderLayout.CENTER);

        JPanel buttonPanel = new JPanel(); //hat automatisch FlowLayout()

        JButton startButton = new JButton("start");
        startButton.addMouseListener(audi);
        audi.setStartButton(startButton);
        buttonPanel.add(startButton);

        JButton endButton = new JButton("end");
        endButton.addMouseListener(audi);
        audi.setEndButton(endButton);
        buttonPanel.add(endButton);

        panel.add(buttonPanel, BorderLayout.PAGE_END);
        frame.setContentPane(panel);
        frame.setVisible(true);
    }

    public void spielen(int prozent, int anzahlSchritte) throws InterruptedException {
        boolean[][] feld = new boolean[100][100];
        feld = feldZufälligInitialisieren(prozent);
        for (int n = 0; n < anzahlSchritte; n++) {
            welt.setFeld(feld);
            welt.repaint();
            Thread.sleep(150);     
            feld = nächsteGeneration(feld);
        }

    }

    public boolean[][] feldZufälligInitialisieren(int p){
        Random rand = new Random();
        boolean[][] neuesFeld = new boolean[100][100];
        for (int i = 0; i < 100; i++) {
            for (int j = 0; j < 100; j++) {
                neuesFeld[i][j] = rand.nextInt(100) < p;
            }
        }
        return neuesFeld;
    }

    private boolean[][] nächsteGeneration(boolean[][] altesFeld){
        boolean[][] neuesFeld = new boolean[100][100];
        for (int i = 0; i < 100; i++) {
            for (int j = 0; j < 100; j++) {
                int nachbarn = getAnzahlNachbarn(altesFeld, i, j);

                if (altesFeld[i][j]) {
                    neuesFeld[i][j] = (nachbarn == 2) || (nachbarn == 3);
                }
                else {
                    neuesFeld[i][j] = nachbarn == 3;

                }
            }
        }
        return neuesFeld;
    }

    public int getAnzahlNachbarn(boolean[][] altesFeld, int x, int y) {
        if (x == 0 || x == 99 || y == 0 || y == 99){
            return 0; // Die Randfelder sollen leer bleiben
        }
        int anzahlNachbarn = 0;
        for (int i = x - 1; i <= x + 1; i++) {
            for (int j = y - 1; j <= y + 1; j++){
                if (altesFeld[i][j]){
                    anzahlNachbarn++;
                }
            }
        }
        if (altesFeld[x][y]){
            anzahlNachbarn--; // Die Zelle an sich rechnen wir raus.
        }
        return anzahlNachbarn;
    }
}

Klasse Welt, die Zeichenklasse, erbt von JPanel:
Java:
import java.awt.*;
import javax.swing.*;

public class Welt extends JPanel
{
    private boolean[][] feld = new boolean[100][100];
   
    public Welt() {
       
    }

    public void setFeld(boolean[][] feld){
        this.feld = feld;
        repaint();
    }

    @Override
    public void paintComponent(Graphics g) {
        super.paintComponent(g);
        // Das Feld
        for (int i = 0; i < 100; i++){
            for (int j = 0; j < 100; j++) {
                if (feld[i][j]) {
                    g.setColor(java.awt.Color.BLACK);
                }
                else {
                    g.setColor(java.awt.Color.WHITE);
                }
                g.fillRect(i * 5, j * 5, 5, 5);
            }
        }
    }
}
Klasse Listener, erbt von MouseAdapter:
Java:
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import javax.swing.JButton;

public class Listener extends MouseAdapter
{
    private JButton startButton;
    private JButton endButton;
    private Logik logik;
    /**
     * Constructor for objects of class Listener
     */
    public Listener(){
    }

    public void mouseReleased( MouseEvent e)
    {
        if(e.getSource() == startButton){
            try{
                logik.spielen(30,10);
           }
            catch(Exception ex) {
                System.out.println("Ooops, an error occured. Close the program and try again.");
            }
        }
        else if(e.getSource() == endButton) {
            System.exit(0);
        }
    }

    public void setStartButton(JButton b){
        startButton = b;
    }

    public void setEndButton(JButton b){
        endButton = b;
    }

    public void setLogik( Logik l){
        logik = l;
    }
}

Es scheint auch von der Logik her alles richtig zu sein, d.h. das Endbild sieht auch vernünftig aus, aber nur dass man halt keine Animation sieht. Ich hoffe, das Problem lässt sich lösen, ohne irgenwelche Threads verlegen zu müssen... bei anderen Projekten lief es auch so.

Liebe Grüße und vielen Dank, Salmo Salar
 
Hallo JCODA, und wieder hilfst du mir: ) Ich habe mir den Timer angeguckt, wenn auch nicht ganz verstanden. Der delay im Konstruktor wären wohl die 150 ms, aber wozu brauche ich einen Listener in den Konstruktor, bzw. wo soll ich einen hernehmen?
Und warum funktioniert alles beim Aufruf der main()-Methode ohne Probleme und auch wenn ich, wie das bei BlueJ möglich ist, erst ein Objekt der Klasse Logik erstelle und dann manuell die Methode spielen() aufrufe und alle Parameter per Hand eingebe?
Und wenn ich einen Aufruf der spielen()-Methode im Konstruktor der Klasse Logik platziere und dann davon ein Objekt erzeuge, funktioniert es.
Nur nicht, wenn ich den Button benutze. Anscheinend wird der (Event-Dispatch)-Thread nicht immer blockiert. Aber vielen Dank schonmal, ich werde mal ein bisschen mit dem Timer rumspielen.
 
Kleiner Nachtrag: Auch wenn ich das Thread.sleep() rausnehme, läuft die Animation nach Knopfdruck nicht. Bei allen anderen Verfahren (Main, Konstruktor, manuell ) läuft dann die Animation trotzdem, schnell und flackernd, aber läuft.
Ich hab nochmal in den Debugger geguckt, da heißt der Thread AWT-EventQueue-0(waiting) neben dem normalen main(finished).
 
Zuletzt bearbeitet:
Alle Aktionen, die in der actionPerformed gestartet wurden, laufen im EDT (der Thread mit den Namen "AWT-EventQueue"). Solange die nicht beendet sind, wird die Gui nicht neu gezeichnet. Alle repaints, die z. B. in einer for-Schleife stehen, werden erstmal "gesammelt" und nach Ende der actionPerformed abgearbeitet. Somit ist es egal, ob du den Thread mit sleep() schlafen legst oder nicht: in jedem Fall geht es mit Gui-updates erst weiter, wenn die Methode beendet ist.
Wenn du die spielen() Methode von der main aus aufrufst, oder im Konstruktor, läft die Schleife offenbar im main Thread. Die repaints() die dort angefordert werden, werden dann sofort ausgeführt.
aber wozu brauche ich einen Listener in den Konstruktor, bzw. wo soll ich einen hernehmen
Der Timer informiert den ActionListener durch versenden eines ActionEvents, wenn der Delay abgelaufen ist. Ein ActionListener könnte z. B. anonym sein, und einfach setFeld auf welt aufrufen.
 
@JCODA @Harry Kane : vielen Dank für eure Hife! Ich habe das Programm zuende gemacht, zumindest vorläufig - es fallen einem immer noch tausend Sachen ein, die auch noch ganz nett wären: )
Falls jemand irgendwann auch an den Timern verzweifelt und ein Beispiel braucht oder einfach nur spielen will, hier ist mein Quellcode:
Klasse Logik mit main()
Java:
import javax.swing.JFrame;
import javax.swing.JButton;
import javax.swing.JTextField;
import java.util.Random;
import java.awt.BorderLayout;
import java.awt.FlowLayout;
import javax.swing.JPanel;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import javax.swing.Timer; <---------------------------------

public class Logik implements ActionListener
{
    private JFrame frame;
    private Welt welt = new Welt();
    private boolean[][] feld;
    private JTextField statusAnzeige;
    private boolean stop;
    private boolean initialisiert;
    private JButton startButton;
    private Timer t;

    public static void main(String args[]) {
        new Logik();
    }

    public Logik()
    {
        // int schrittzahl = 0;
        stop = false;
        initialisiert = false;
        //designFeld = new boolean[100][100];
        feld = new boolean[100][100];

        t = new Timer(150, this); <--------------------------------

        frame = new JFrame("Game of Life");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(515, 575);        //je nach Feldgröße

        Listener audi = new Listener();
        audi.setLogik(this);
        JPanel panel = new JPanel();
        panel.setLayout(new BorderLayout());

        welt.addMouseListener(audi);
        panel.add(welt,BorderLayout.CENTER);

        JPanel buttonPanel = new JPanel(); //hat automatisch FlowLayout()

        statusAnzeige = new JTextField("200", 3);
        System.out.println(statusAnzeige.getText());
        buttonPanel.add(statusAnzeige);

        JButton resetButton = new JButton("reset");
        resetButton.addMouseListener(audi);
        audi.setResetButton(resetButton);
        buttonPanel.add(resetButton);

        JButton initButton = new JButton("init");
        initButton.addMouseListener(audi);
        audi.setInitButton(initButton);
        buttonPanel.add(initButton);

        startButton = new JButton("start");
        startButton.addMouseListener(audi);
        audi.setStartButton(startButton);
        buttonPanel.add(startButton);

        JButton endButton = new JButton("end");
        endButton.addMouseListener(audi);
        audi.setEndButton(endButton);
        buttonPanel.add(endButton);

        panel.add(buttonPanel, BorderLayout.PAGE_END);
        frame.setContentPane(panel);
        frame.setVisible(true);
    }

    public void spielen(int prozent) 
    {
        System.out.println(statusAnzeige.getText());
        System.out.println(Integer.parseInt(statusAnzeige.getText()));
        startButton.setText("stop");
        try
        {
            int schrittzahl = Integer.parseInt(statusAnzeige.getText());
        }
        catch(NumberFormatException e)
        {
            System.out.println("Sie haben eine ungültige Zahl eingegeben. Error: " +e.toString());
        }
        if(!initialisiert)
        {
            feld = feldZufälligInitialisieren(prozent);
        }
        initialisiert = true;

        t.start(); <-----------------------------------------------------------------------------
    }

    public boolean[][] feldZufälligInitialisieren(int p)
    {
        Random rand = new Random();
        boolean[][] neuesFeld = new boolean[100][100];
        for (int i = 0; i < 100; i++)
        {
            for (int j = 0; j < 100; j++)
            {
                neuesFeld[i][j] = rand.nextInt(100) < p;
            }
        }
        return neuesFeld;
    }

    private boolean[][] nächsteGeneration(boolean[][] altesFeld)
    {
        boolean[][] neuesFeld = new boolean[100][100];
        for (int i = 0; i < 100; i++)
        {
            for (int j = 0; j < 100; j++)
            {
                int nachbarn = getAnzahlNachbarn(altesFeld, i, j);

                if (altesFeld[i][j])
                {
                    neuesFeld[i][j] = (nachbarn == 2) || (nachbarn == 3);
                }
                else
                {
                    neuesFeld[i][j] = nachbarn == 3;
                }
            }
        }
        return neuesFeld;
    }

    public int getAnzahlNachbarn(boolean[][] altesFeld, int x, int y)
    {
        if (x == 0 || x == 99 || y == 0 || y == 99)
        {
            return 0; // Die Randfelder sollen leer bleiben
        }
        int anzahlNachbarn = 0;
        for (int i = x - 1; i <= x + 1; i++)
        {
            for (int j = y - 1; j <= y + 1; j++)
            {
                if (altesFeld[i][j])
                {
                    anzahlNachbarn++;
                }
            }
        }

        if (altesFeld[x][y])
        {
            anzahlNachbarn--; // Die Zelle an sich rechnen wir raus.
        }
        return anzahlNachbarn;
    }

    public void zelleHinzufügen(int x, int y)
    {
        feld[x][y] = !feld[x][y];
        welt.setFeld(feld);
        initialisiert = true;
    }

    public void reset()
    {
        for (int i = 0; i < 100; i++)
        {
            for (int j = 0; j < 100; j++)
            {
                feld[i][j] = false;
            }
        }
        setButtonToStart();
        welt.setFeld(feld);
        initialisiert = false;
    }

    public void setStop(boolean b)
    {
        stop = b;
        if(stop)
        {          
               startButton.setText("continue");
        }
        else
        {
           startButton.setText("stop");
        }
    }

    @Override public void actionPerformed(ActionEvent e)
    {
        int schrittzahl = Integer.parseInt(statusAnzeige.getText());
        if(schrittzahl < 1 || stop)
        {
            welt.setFeld(feld);
            t.stop();<-----------------------------------------------------------------------------
            if(schrittzahl < 1)
            {
                schrittzahl = 200;
                setStop(true);
            }
        }
        else
        {
            welt.setFeld(feld);    
            feld = nächsteGeneration(feld);
            schrittzahl -- ;
        }
        statusAnzeige.setText(Integer.toString(schrittzahl));
    }

    public String getButtonText()
    {
        return startButton.getText();
    }

    public void setButtonToStart()
    {
        startButton.setText("start");
    }

    public boolean getIsRunning()
    {
        boolean b = t.isRunning(); <--------------------------------------------------------------------------
        return b;
    }
  
}

Klasse Listener
Java:
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import javax.swing.JButton;

public class Listener extends MouseAdapter
{
    private JButton resetButton;
    private JButton initButton;
    private JButton startButton;
    private JButton endButton;
    private JButton stopButton;
    private Logik logik;
    private boolean initLäuft;

    public Listener()
    {
        initLäuft = false;
    }

    public void mouseReleased( MouseEvent e)
    {
        if (e.getSource() == initButton)
        {
            logik.setStop(true);
            initLäuft = true;
            logik.setButtonToStart();
        }
        else if(e.getSource() == startButton)
        {
            initLäuft = false;
            if(logik.getButtonText().equals("stop"))
            {
                {
                    logik.setStop(true); 
                }
            }
            else if(logik.getButtonText().equals("continue"))
            {
                logik.setStop(false);
                spielenStarten();
            }
            else
            {
                spielenStarten();
            }
        }
        else if(e.getSource() == endButton)
        {
            System.exit(0);
        }
        else if(e.getSource() == resetButton)
        {
            logik.reset();
        }
        else if(initLäuft)
        {
            int xKoordinate = e.getX();
            int yKoordinate = e.getY();
            zelleBestimmen(xKoordinate,yKoordinate);
        }
    }

    public void zelleBestimmen(int x, int y)
    {
        int xKoordinate = x/5;
        int yKoordinate = y/5;
        System.out.println(xKoordinate+"|"+yKoordinate);
        logik.zelleHinzufügen(xKoordinate, yKoordinate);
    }

    public void setResetButton(JButton b)
    {
        resetButton = b;
    }

    public void setInitButton(JButton b)
    {
        initButton = b;
    }

    public void setStartButton(JButton b)
    {
        startButton = b;
    }

    public void setEndButton(JButton b)
    {
        endButton = b;
    }

    public void setLogik( Logik l)
    {
        logik = l;
    }

    public void spielenStarten()
    {
        System.out.println("logik.spielen");
        logik.setStop(false);
        logik.spielen(30);
    }
}

Klasse Welt (JPanel)
Java:
import java.awt.*;
import javax.swing.*;

public class Welt extends JPanel
{
    private boolean[][] feld = new boolean[100][100];

    /**
     * Constructor for objects of class Welt
     */
    public Welt()
    {
      
    }

    public void setFeld(boolean[][] feld)
    {
        this.feld = feld;
        repaint();
    }

    @Override
    public void paintComponent(Graphics g)
    {
        super.paintComponent(g);
        // Das Feld
        for (int i = 0; i < 100; i++)
        {
            for (int j = 0; j < 100; j++)
            {
                if (feld[i][j])
                {
                    g.setColor(java.awt.Color.BLACK);
                }
                else
                {
                    g.setColor(java.awt.Color.WHITE);
                }
                g.fillRect(i * 5, j * 5, 5, 5);
            }
        }
    }
}
Alle Sachen, die mit Timern zu tun haben sind durch Pfeile hervorgehoben.
Das bedeuten die Buttons:
*Start: Bei leerem Feld startet die Simulation mit einer Zufallsverteilung von 30%, bei selbst Initialisiertem mit der gewünschten Kombination. Danach fungiert der Button als stop/play-Taste.
*Init: Der Spieler kann Kästchen auf dem Feld anklicken und ein eigenes Startmuster erzeugen.
*Reset: Das Feld wird geleert.
*End: Das Programm wird geschlossen.
Im kleinen Textfeld kann man selber eine Schrittzahl eingeben. Bei der Zufallsverteilung sind etwa 1000 Schritte ratsam.

Einen schönen Sommer euch allen, Salmo Salar
 

Zurück
Oben