Programmaufbau in Ordnung? Problem mit paintComponent()

[h4nk]

Hallo Leute, ich versuche gerade "Game of Life" bzw. das Spiel des Lebens zu implementieren.

Momentan soll es nach Model-View-Controller aufgebaut sein, womit ich mich rechts schwer tue. Vorallem zu unterscheiden, was jetzt wohin gehört. Sind das meistens wirklich nur drei Klassen?! Oder mach ich da schon den ersten Fehler?

Der Controller managt bei mir nur den Spielablauf. Er hat als Attribute Model und View hinzugefügt bekommen und besitzt eine Methode startSimulation(), in der in einer Endlosschleife die Methoden vom Model und View aufgerufen werden um das Spielfeld neu zu berechnen und danach das Panel zu "repainten".

Mein View ist momentan da größte Problem. Hier gibts eine Methode createGUI(), in der einem Fram ein MyPanel hinzugefügt wird. MyPanel ist eine innere Klasse von View und erbt von JPanel für die paintComponent()-Methode, anfangs und nach jeder Neuberechnung des Spielfelds repainted werden soll.

Leider wird meine verschachtelte for-Schleife in paintComponent() nicht aufgerufen, um für jedes "Feld" des Spielfelds ein Quadrat zu malen.

Das Model ist gefühlt ein Monster, keine Ahnung ob die ganzen Methoden überhaupt noch als "Businesslogik" akzeptabel sind.. In der Klasse wird das Spielfeld gespeichert und jede Zelle/jedes Feld neu berechnet.

Gehören die Methoden da hin oder lieber in den Controller (wobei der ja eigentlich nur als Vermittler dienen sollte?!)

So, genug gelabert.

Model

public class Model
{
   private boolean[][] field;
   private boolean[] neighbours = new boolean[8];
       
   // Constructor
   public Model (int size)
   {
       this.field = new boolean[size][size];
   }
       
   public boolean[][] refreshField()
   {
       for (int y = 0; y > this.field.length; y++)
       {
           for (int x = 0; x > this.field[y].length; x++)
           {   
               chooseAction(x, y);   
           }
       }            
       return this.field;
   }
   
   
   // Get neighbours
   public boolean[] getNeighbours (int x, int y)
   {
       try
       {
           this.neighbours[0] = this.field[y - 1][x - 1];
           this.neighbours[1] = this.field[y - 1][x];
           this.neighbours[2] = this.field[y - 1][x + 1];
           
           this.neighbours[3] = this.field[y][x - 1];
           this.neighbours[4] = this.field[y][x + 1];
           
           this.neighbours[5] = this.field[y + 1][x - 1];
           this.neighbours[6] = this.field[y + 1][x];
           this.neighbours[7] = this.field[y + 1][x + 1];
       }
       catch (Exception e)
       {
           System.err.println("Spielfeld zu klein.");
       }       
       return this.neighbours;
   }
   
   public void chooseAction (int x, int y)
   {
       int counter = 0;
       
       for (boolean b : getNeighbours(x, y))
       {
           if (b == true)
           {
               counter++;
           }   
       }
       
       if (this.alive(x, y))
       {
           if (counter < 2)
           {
               lonliness(x, y);
           }
           else if (counter > 3)
           {
               overpopulation (x, y);
           }
       }
       else
       {
           if ( counter == 3)
           {
               reproduction(x, y);
           }
       }       
   }
       
   public void reproduction (int x, int y)
   {
       this.born(y, x);
   }
   
   public void lonliness (int x, int y)
   {
       this.kill(y, x);       
   }
   
   public void overpopulation (int x, int y)
   {
       this.kill(y, x);   
   }   
   
   // Sets cell to alive
   public void born (int y, int x)
   {
       this.field[y][x] = true;
   }
   
   // Kills cell
   public void kill (int y, int x)
   {
       this.field[y][x] = false;
   }
   
   public boolean alive (int y, int x)
   {
       if(this.field[y][x] = true)
       {
           return true;
       }
       else
       {
           return false;
       }
   }
   
   // Getter
   public boolean[][] getFeld()
   {
       return field;
   }   
}

View

public class View  
{
   private JFrame frame;
   private MyPanel panel;
   
   private boolean[][] field;
   
   
   public void createGUI ()
   {
       frame = new JFrame();
       frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
       
       panel = new MyPanel();
       
       
       frame.getContentPane() .add(BorderLayout.CENTER, panel);
       
       frame.setSize(1000, 1000);
       frame.setVisible(true);     
   }
   
   
   
   public void setField(boolean[][] field)
   {
       this.field = field;
   }


   public JPanel getPanel()
   {
       return panel;
   }
   
   
   public class MyPanel extends JPanel
   {
       private static final long serialVersionUID = 1L;
       
       public void paintComponent(Graphics g)
       {
           g.setColor(Color.white);
           g.fillRect(0, 0, frame.getWidth(), frame.getHeight());   
           
           for (int y = 0; y > field.length; y++)
           {
               for (int x = 0; x > field[y].length; x++)
               {   
                   g.setColor(Color.black);
                   g.fillRect(0, 0, 75, 75);   
               }
           }
       }   
   }
   
}

Controller

public class Control
{
   private View view;
   private Model model;
   
   public void startSimulation()
   {
       while(true)
       {
           view.createGUI();
           view.setField(model.refreshField());
           view.getPanel().repaint();
           
           try
           {
               Thread.sleep(150);
           }
           catch (InterruptedException e)
           {
               System.err.println("Unterbrochen.");
           }   
       }   
   }
   
   
   public void addView(View view)
   {
       this.view = view;
   }
   
   public void addModel(Model model)
   {
       this.model = model;
   }
}

Starter

public class Starter
{
   public static void main(String[] args)
   {
       int size = 100;
       
       Model myModel = new Model(size);
       View myView = new View();
       
       Control myController = new Control();
       myController.addView(myView);
       myController.addModel(myModel);
       
       myController.startSimulation();   
   }
}

 

[iBrain]

Das MVC prinzip was auch observer pattern genannt wird heisst nicht nur so weil es Model View und Controller gibt sondern es sind in der regel auch die abstrakte klasse Observable und das interface Observer(ich weiss man könnte denken es ist andersrum wegen der namensgebung doch dem ist nicht so) involviert.Dazu gleich mehr.

In deiner klasse Model werden die roh daten deines spiels gespeichert(Sprich zb dein spielfeld welches felder hat dein spieler welcher auf einem bestimmten feld steht ein würfel der geworfen wird zb).Allerdings würde ich dir empfehlen dein Spielfeld in einer separaten klasse pitch oder PlayingField oder playground oder wie du sie halt nennen willst abzulegen sodass du die möglichkeit hast später einfach weitere komponenten zu deinem model hinzuzufügen.

Sobald du diese klasse deinem projekt hinzugefügt hast implementierst du sie in dein Model und greifst über dein Model objekt später über den getter direkt auf das playground-objekt zu.
das könnte so aussehen

public class Model extends Observable{
    Playground playground;
    public Model(){
    playground = new Playground(//irgendwelche initialisierungswerte);
    }

    public Playground getPlayground(){
        return this.playground;
    }

    public void setPlayground(Playground playground){
        this.playground = playground;
        customNotifyAll();
    }
 //hier halt noch eine setter methode für playground und evtl getter und setter für andere elemente

 /*und die methoden die zu obserable gehören (ich habe hier eine methode eingefügt mit beiden befehlen die zu observable gehören.somit müsste man theoretisch nur noch customNotifyAll() aufrufen sobald sich ein objekt über einen setter ändert und die observer werden sofort über die status veränderung benachrichtigt.)
Beide methoden setchanged und notifyobservers sind nötig um "angemeldete observer" zu benachrichtigen falls sich was am zustand des models ändert,sollten also von jeder methode implementiert werden die Observable erweitern*/

    private void customNotifyAll(){
        setChanged();
        notifyObservers(this);
    }

}

soweit zu deinem model.

Also zu deiner frage gehören die methoden da hin . Jein.Sie gehören zu deinem objekt im model aber sollten nicht im model selber stehen.das model bietet nur zugriff auf die spielobjekte welche wiederrum zugriff über getter auf die jeweiligen objekt-attribute geben.

Zum controller:
Der controller muss unbedingt von überall ausser aus dem model heraus zugänglich sein.Dein model hat keine ahnung vom controller.Der controller wiederrum muss vom model wissen und von der view.Die view muss auch vom controller wissen.wie realisiert man das ? Also.

Deine main methode von der du aus startest könnte ungefähr so aussehen.

public class MainApp
{
    MainApp(){
        Model model = new Model();
        Controller controller = new Controller(model);
        View view = new View(controller);
    }

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

1.Das model wird initialisiert und bringt die daten mit die nötig sind um das spiel zu bestreiten.
2.Der Controller wird als zweites initialisiert und diesem wird im konstruktor das model übergeben(der controller hat ein Model objekt in der klasse).
3.Der view wird der controller übergeben damit man aus der view heraus darauf zugreifen kann UND damit man dem controller die view ebenfalls übergeben kann(wie das funktioniert kommt gleich).

Die klasse Controller könnte ungefährt so aussehen

public class Controller{
Model model;
View view;
    public Controller(Model model){
        this.model = model
    }

    //getter und setter für das model und die view
}

Somit weiss der controller über alles bescheid was im programm abläuft.

Zur view:
Die view wird wie oben beschrieben nach dem controller initialisiert(Die reihenfolge ist ausgeprochen wichtig).Aussderdem sollte deine view aus meiner sicht aber das ist vllt ansichtssache direkt JFrame erweitern.

Deine view könnte folgendermassen aussehen:

public class View extends JFrame{

    private Controller controller;
    private MeinJPanel jPanel;

    public View(Controller controller) {
        this.controller = controller;
        controller.setView(this); //HIER WIRD DEM CONTROLLER DIE VIEW ÜBER this ÜBERGEBEN
        this.setTitle("Dein spielname");
        this.setSize(grösse xy zb 300,300 oder so);
        this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        jPanel = new JPanel(controller);
        this.add(jPanel);
        this.setVisible(true);

    }

    public Controller getcontroller() {
        return controller;
    }

    public void setController(Controller controller) {
        this.controller = controller;
    }//getter und setter für deinen panel

Jetzt wird dein fenster initialisiert sobald du deine main methode aufrufst und deine view ist direkt visible weil
this.setVisible(true);
schon im konstruktor aufgerufen wird.wie du siehst wurde auch dem jpanel der controller übergeben.Das ist der letzte wichtige punkt im pattern.

Deine klasse jpanel ist ja die jenige klasse die das zeichnen soll was sich im model verändert.du hast jetzt in deinem panel die möglichkeit über dein model auf jede erdenkliche veränderung zu reagieren und zwar durch das interface Observer.

Deine klasse könnte (ohne implementierung deiner spielspezifischen sachen) jetzt ca so aussehen:

public class MeinJPanel implements Observer{
    Controller controller;
    //hier verschiedene elemente deines panels

    MeinJPanel(Controller controller){
        this.controller = controller;
    }
 
    //hier spezifische methoden deines panels die direkt auf dein model zugreifen und es verändern     können weil dein controller auf alle eigenschaften deines models zugreifen kann.
/*
Und unten in der klasse implementierst du die methode die zum Observer interface gehört
diese methode wird immer dann aufgerufen wenn dein Observable notifyObservers(this); aufruft
du kannst diese methode übrigens jeder klasse geben die observable erweitert
*/
@Override
public void update(Observable o, Object arg) {
    /*hier noch spezifische dinge die du an der view ändern willst sobald sich was am model ändert auf die du ja direkt über den controller zugreifen kannst weil dieser deinem jpanel bekannt ist und weil diese methode eben nur bei änderung an deinem observable sprich deinem model aufgerufen wird.*/
    revalidate();
    repaint();
    }

}

Man kann sich als fazit merken:Alles aus der view muss den controller übergeben bekommen um aus allem aus deinem model reagieren zu können.Wenn deine view verändert wird kannst du direkt aus der view eine veränderung an deinem model herbeiführen in dem du über deinen controller der in der view liegt auf das model zu greifst und die änderung direkt wie gewünscht herbeiführst.

Falls du noch eine frage hast und ich was vergessen haben sollte tuts mir leid ^^.Ich hoffe meine antwort konnte dir zumindest ein wenig weiterhelfen.

 

[iBrain]

Mir ist gerade noch was eingefallen.Ich habe vergessen zu erwähnen das ein Observer sich beim Observable anmelden muss.

An dem beispiel von oben wäre das folgende zeile im Kontruktor des Observers mehr um sich beim model als observer anzumelden...sonst funktioniert der ganze zauber natürlich nicht richtig :
this.controller.getModel().addObserver(this);

Fast vergessen uiuiui.....

 

[h4nk]

Sehr ausführlich und hilfreich. Velen Dank dafür! Ich werde die Vorschläge heute umsetzen und mich dann zurückmelden.

 

[iBrain]

Ich muss mich leider etwas berichtigen.Mein erster Satz war nicht ganz richtig.Das MVC prinzip heisst nicht auch observer pattern sondern nutzt das observer pattern im normalfall zum event handling,es gibt da noch ganz andere techniken.Da ist mir wohl ein fehler unterlaufen . War für mich schon so selbstverständlich das ich das ganze direkt in einen topf geworfen habe!Sollte aber hoffe ich kein problem sein für deine umsetzung.Sorry hehe

 

[h4nk]

So, konnte soweit alles gut umsetzen, denke ich. Habe das Programm jetzt soweit, dass man Felder anklicken kann um sie zu beleben und seine Startformation zu erstellen. Danach kann man auf einen Button drücken und die Simulation wird gestartet. Jeder Klick zählt dabei für 100 Runden.

Leider habe ich das Problem, dass, egal wo ich die notifyAll-Methode hinpacke, nur am Ende einmal repainted wird. Sprich man klickt auf den Knopf, er rechnet und zeigt die Endposition nach 100 Zügen. MEin Ziel ist es allerdings den Prozess dahin abzubilden, also am besten nach jeder Feldänderung einen repaint. Habe schon versucht mit Thread.sleep(..) zu arbeiten und die notifyAll-Methode an verschiedene Stellen positioniert – leider kein Erfolg.

Starter

public class Starter
{
   public Starter()
   {
       Model myModel = new Model();
       Controller myController = new Controller(myModel);  
      
       @SuppressWarnings("unused")
       View myView = new View(myController);          
   }
  
   public static void main(String[] args)
   {
       new Starter();
   }
}

Model

public class Model extends Observable
{
   private Playfield field;
  
   // Konstruktor
   public Model()
   {
       this.field = new Playfield(100);
   }

   // Getter und Setter
   public Playfield getPlayfield()
   {
       return field;
   }  
}

Playfield

package model;

import java.util.Observable;

public class Playfield extends Observable
{
   private boolean[][] field;
   private boolean[] neighbours = new boolean[8];
  
  
   // Konstruktor
   public Playfield (int size)
   {
       this.field = new boolean[size][size];
   }
  
  
   public void startSimulation() throws InterruptedException
   {
       // Endlosschleife in der nach jeder Runde das Spielfeld neu geladen wird.
       // while(true)
       for (int i = 0; i < 100; i++)
       {
           refreshField();
       }
   }
  
  
   // Erneuert das Spielfeld und gibt ein neues zurück
   public void refreshField()
   {
       for (int y = 0; y < this.field.length; y++)
       {
           for (int x = 0; x < this.field[y].length; x++)
           {  
               if (y != 0 || x != 0 || y != this.field.length-1 || x != this.field.length-1)
               {
                   chooseAction(x, y);  
               }
           }
       }   
   }
  
  
   // Wählt Aktion um Zelle zu töten oder wiederzubeleben
   public void chooseAction (int x, int y)
   {
       int counter = 0;
      
       for (boolean b : getNeighbours(x, y))
       {
           if (b == true)
           {
               counter++;
           }  
       }
      
       if (this.field[y][x] == true)
       {
           if (counter < 2)
           {
               lonliness(x, y);
           }
           else if (counter > 3)
           {
               overpopulation (x, y);
           }
       }
       else
       {
           if ( counter == 3)
           {
               reproduction(x, y);
           }
       }      
   }
      
  
   // Get neighbours
   public boolean[] getNeighbours (int x, int y)
   {
       try
       {
           this.neighbours[0] = this.field[y - 1][x - 1];
           this.neighbours[1] = this.field[y - 1][x];
           this.neighbours[2] = this.field[y - 1][x + 1];
          
           this.neighbours[3] = this.field[y][x - 1];
           this.neighbours[4] = this.field[y][x + 1];
          
           this.neighbours[5] = this.field[y + 1][x - 1];
           this.neighbours[6] = this.field[y + 1][x];
           this.neighbours[7] = this.field[y + 1][x + 1];
       }
       catch (Exception e)
       {
           // System.err.println("Spielfeld zu klein.");
       }      
       return this.neighbours;
   }
  
  
   // Methoden um zu ermitteln, ob die Zelle lebt oder stirbt.
   public void reproduction (int x, int y)
   {
       this.born(x, y);
   }
  
   public void lonliness (int x, int y)
   {
       this.kill(x, y);      
   }
  
   public void overpopulation (int x, int y)
   {
       this.kill(x, y);  
   }  
  
   public boolean isAlive(int x, int y)
   {
       if (field[y][x] == false)
       {
           return false;
       }
       return true;          
   }
  
   // Zelle töten oder wiederbeleben
   public void born (int x, int y)
   {
       this.field[y][x] = true;
       customNotifyAll();
      
   }
  
   public void kill (int x, int y)
   {
       this.field[y][x] = false;
       customNotifyAll();
      
   }
      
   // Getter und Setter
   public boolean[][] getField()
   {
       return field;
   }  
  
   public void setField(boolean[][] field)
   {
       this.field = field;
   }
  
   public void customNotifyAll()
   {
       setChanged();
       notifyObservers(this);
   }
}

View

package view;

import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;

import control.Controller;


public class View extends JFrame implements ActionListener
{
   private static final long serialVersionUID = 1L;
  
   private Controller controller;
   private MyPanel panel;
  
  
   public View(Controller controller)
   {
       this.controller = controller;
      
       controller.setView(this);
      
       JButton button = new JButton("Wenn du eine Startformation gewählt hast, klicke hier um die Simulation zu starten.");
       button.addActionListener(this);
      
       panel = new MyPanel(controller);
      
       this.getContentPane() .add(BorderLayout.CENTER, panel);
       this.getContentPane() .add(BorderLayout.SOUTH, button);
      
       this.setSize(1100, 1150);
       this.setTitle("Game of Life");
      
       this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
       this.setVisible(true);    
   }
  
  
   // Getter und Setter – Controller
   public Controller getController()
   {
       return controller;
   }

   public void setController(Controller controller)
   {
       this.controller = controller;
   }

  
   // Getter und Setter – Panel
   public MyPanel getPanel()
   {
       return panel;
   }

   public void setPanel(MyPanel panel)
   {
       this.panel = panel;
   }


   @Override
   public void actionPerformed(ActionEvent e)
   {
       try
       {
           this.controller.getModel().getPlayfield().startSimulation();
       }
       catch (InterruptedException e1)
       {
           e1.printStackTrace();
       }
   }
}

MyPanel

package view;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.MouseInfo;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.Observable;
import java.util.Observer;

import javax.swing.JPanel;

import control.Controller;

public class MyPanel extends JPanel implements Observer
{
   private static final long serialVersionUID = 1L;
   Controller controller;
  
  
   // Konstruktor
   public MyPanel(Controller controller)
   {
       this.controller = controller;
       this.controller.getModel().getPlayfield().addObserver(this);
      
       this.addMouseListener(new MouseAdapter()
       {
           @Override
            public void mousePressed(MouseEvent e)
           {
               // Position of mouse
               double frameX = controller.getView().getLocationOnScreen().getX();
               double frameY = controller.getView().getLocationOnScreen().getY();  
              
               double mouseX = MouseInfo.getPointerInfo().getLocation().getX();
               double mouseY = MouseInfo.getPointerInfo().getLocation().getY();
              
               int x = (int) (mouseX - frameX) / 11;
               int y = (int) ((mouseY - frameY) / 11) - 2;
              
               // clicked on cell set to alive
               controller.getModel().getPlayfield().born( x, (int) y);
            }
        });
   }
  
  
   public void paintComponent(Graphics g)
   {
       g.setColor(Color.white);
       g.fillRect(0, 0, controller.getView().getWidth(), controller.getView().getHeight());  
      
       for (int y = 0; y < controller.getModel().getPlayfield().getField().length; y++)
       {
           for (int x = 0; x < controller.getModel().getPlayfield().getField()[y].length; x++)
           {  
               if (controller.getModel().getPlayfield().isAlive(x, y))
               {
                   g.setColor(Color.white);
                   g.fillRect(x + (x * 10), y + (y * 10), 10, 10);  
               }
               else
               {
                   g.setColor(Color.black);
                   g.fillRect(x + (x * 10), y + (y * 10), 10, 10);  
               }
           }
       }
   }

   @Override
   public void update(Observable o, Object arg)
   {
       revalidate();
       repaint();
   }  
}

Controller

package control;

import view.View;
import model.Model;


public class Controller
{
   private View view;
   private Model model;
  
   public Controller(Model model)
   {
       this.model = model;
   }
  
   public void setView(View view)
   {
       this.view = view;
   }
  
   public View getView()
   {
       return this.view;
   }

   public Model getModel()
   {
       return model;
   }

   public void setModel(Model model)
   {
       this.model = model;
   }
}

 

[Harry Kane]

Wenn deine view verändert wird kannst du direkt aus der view eine veränderung an deinem model herbeiführen in dem du über deinen controller der in der view liegt auf das model zu greifst und die änderung direkt wie gewünscht herbeiführst.

Nach meinem Verständnis vom MVC sollte der Programmfluss gerade so NICHT sein (view wird geändert und das model wird informiert), sondern umgekehrt.

Hier mal ein paar Kommentare zum Code:

Dein Model enthält nur das Playfield und bietet sonst keine Funktionalität. Die Klasse kann weg. Überall dort, wo Model verwendet wird, kannst du gleich Playfield verwenden. Dann kannst du dir es auch sparen, dass beide Klassen Observable erweitern. Das Argument von iBrain mit der späteren Erweiterung des Model um weitere Komponenten ist mir zu abstrakt.

Die Trennung zwischen der „View“ und dem „MyPanel“ ist überflüssig. Dein MyPanel ist deine View! Das erkennt man schon daran, dass MyPanel Observer implementiert, View aber nicht. Du brauchst natürlich noch ein JFrame, um das MyPanel anzuzeigen, aber dazu reicht ein „normales“ JFrame. Wenn MyPanel die View ist, kannst du die View z. B. ohne weiteres in eine JScrollPane oder ein JTabbedPane packen.

Deine Controller-Klasse ist weitgehend arbeitslos. Sie hält lediglich Referenzen auf View und Model und bietet sonst keine Funktionalität. Vorschlag: mache deiner View (also dem MyPanel) das Model (also das Playfield) direkt zugänglich.

Das boolean[][] field der Klasse Playfield ist öffentlich zugänglich. Dies halte ich für ein NoGo, weil dadurch jedes Objekt, das eine Referenz auf Playfield bekommt, das Array nach Belieben ändern kann, sogar die Dimensionen (z. B. mit field[0] = new boolean[4]). Andererseits fehlt ein getter für die size. Mit einer getSize() und der Änderung aus dem letzten Absatz wird aus den folgenden Zeilen der paintComponent von MyPanel:

        for (int y = 0; y < controller.getModel().getPlayfield().getField().length; y++) {
            for (int x = 0; x < controller.getModel().getPlayfield().getField()[y].length; x++) {
                if (controller.getModel().getPlayfield().isAlive(x, y)) {
                } else {
                }
            }
        }

Das hier:

        for (int y = 0; y < model.getSize(); y++) {
            for (int x = 0; x < model.getSize(); x++) {
                if (model.isAlive(x, y)) {
                } else {                }
            }
        }

Das Verarbeiten des MouseEvents hat in der View-Klasse nichts zu suchen! Das ist mMn eine klassische Controlleraufgabe. Das einzige, was die View dabei tun sollte, ist, die Koordinaten des Mausevents (an die du übrigens mit e.getX() und e.getY() rankommst) in „Feldkoordinaten“ umzurechnen. Das heisst:

- Der Benutzer klickt auf das Feld, der Controller wird informiert.
- Der Controller fragt bei der View nach den Feldkoordinaten, an denen die Maus geklickt wurde.
- Der Controller ruft auf dem Model born() mit den Feldkoordinaten auf.

Nun zu der Frage, warum du die einzelnen Schritte nicht als „Film“ angezeigt bekommst, sondern nur das fertige Ergebnis. Du rufst startSimulation aus der actionPerformed auf. Damit läuft startSimulation im sogenannten Event Dispatching Thread. Dieser ist auch für das Neuzeichnen der Komponenten verantwortlich. Bei jeder Änderung im Playfield, die customNotifyAll aufruft, ruft MyPanel zwar repaint() auf, dies führt aber nicht zu einem sofortigen Neuzeichnen, sondern nur dazu, dass die MyPanel Instanz beim Repaintmanager für das „Neuzeichnen bei der nächsten Gelegenheit“ vorgemerkt wird. Diese Gelegenheit ist aber erst gekommen, wenn die actionPerformed beendet ist, und das wiederum ist erst dann der Fall, wenn die Simulation durchgelaufen ist.

Ich würde die empfehlen, einen javax.swing.Timer zu benutzen. Als ActionListener für den Timer käme der Controller in Frage. Wenn der Timer gestartet wird, informiert er in festgelegten Abständen den Controller. Der Controller zählt die Aufrufe mit und stoppt den Timer nach 100 Aufrufen. Der Controller ruft ausserdem bei jedem Aufruf refreshField() auf dem Model (dem Playground) auf.

Noch ein paar Kleinigkeiten:
b == true bzw. this.field[y][x] == true schreibt man einfach b bzw. this.field[y][x]
Statt

        for (int y = 0; y < this.field.length; y++) {
            for (int x = 0; x < this.field[y].length; x++) {
                if (y != 0 || x != 0 || y != this.field.length - 1 || x != this.field.length - 1) {
                }
            }
        }

Kannst du schreiben

        for (int y = 1; y < this.field.length - 1; y++) {
            for (int x = 1; x < this.field[y].length - 1; x++) {
            }
        }

 

[iBrain]

Ich stimme vollkommen zu das war wohl ein fehler meinerseits das so auszudrücken!Danke für die berichtigung!

 

[h4nk]

Wirklich top Antworten hier, danke. Ich werde es morgen oder die Tage umsetzen.

 

[Harry Kane]

Bei einer genaueren Betrachtung des Codes und ein paar Testläufen sind mir ein paar Fehler und Unstimmigkeiten aufgefallen.
1. Die Verwendung von [x] und [y] in der Playfield-Klasse ist verwirrend. Manchmal tauschen x und y die Rollen, z. B. bei

public boolean isAlive(int x, int y){
      if (field[y][x] == false){
            return false;
      }
      return true;          
}

Du scheinst da aber konsequent bei jedem Zugriff auf field zu machen, von daher mag es "richtig" sein. ich fands aber verwirrend.
2. Bei jedem Simulationsdurchlauf veränderst du die Felder. So wie ich das Konzept verstanden habe, sollen die Änderungen (welche Zelle stirbt oder neu geboren wird) erst nach dem Durchlauf greifen, d. h. eine lebende Zelle mit zuviel oder zuwenig Nachbarn soll erst im nächsten Durchgang sterben, du tötest sie aber sofort.
Erst nachdem ich das korrigiert hatt, hat sich das Spiel so verhalten wie erwartet.

 

[h4nk]

Ja, gut beobachtet. Das habe ich absichtlich gemacht, weil ein Array bei mir im Kopf senkrecht liegt. Bei einem mehrdimensionalen Array sind dann noch horizontale Arrays in den Fächern. Dadurch würde der erste Platz beim Field[1][2] zu y werden. Wenn man so drüber nachdenkt, macht es natürlich Sinn es einheitlich zu machen und sich von diesem Model zu verabschieden Das andere ist mir auch schon aufgefallen, das ändere ich noch.