GilgaTech.com: Game of Life

package interfaces; import java.awt.Color; /** * @author MilkToast * Das Interface InterfaceZellen, stellt alle Methoden der einzelnen Zellen zur * Verfügung */ public interface InterfaceZellen { public String getZustand(); public void setZustand(String zustand); public void setFarbe(Color farbe); public Color getFarbe(); public void setAlter(int alter); public int getAlter(); public boolean getLeben(); public void setLeben(boolean leben); public boolean getSterben(); public void setSterben(boolean sterben); public void setGeneration(int generation); public int getGeneration(); public void erhoeheGeneration(); public void erhoeheAlter(); public void setRotBlau(); }

package gui; import java.awt.*; import java.awt.event.ItemListener; import javax.swing.*; import javax.swing.text.*; import berechnung.Wertuebergabe; /** * * @author MilkToast * */ /** * Die Klasse GUI erstellt das Startmenü für die Simulation * hier werden alle Komponenten erstellt die der Benutzer später * mit Werten füllen kann. * * */ public class Gui extends JFrame{ private JLabel jLBreite = new JLabel("Breite des Lebensraums "); private JLabel jLHoehe = new JLabel("Höhe des Lebensraums"); private JLabel jLVerzoegerung = new JLabel("Verzögerung (msec"); private JLabel jLLeben = new JLabel("Überlebensregel"); private JLabel jLGeburt = new JLabel("Geburtenregel"); private JLabel jLSterben = new JLabel("Sterberegel"); private JLabel jLWahrscheinlichkeit = new JLabel("Wahrscheinlichkeit"); private JLabel jLPlatzhalter = new JLabel(); public JSlider jSBreite = new JSlider(0,300); public JSlider jSHoehe = new JSlider(0,150); public JSlider jSVerzoegerung = new JSlider(0,1000); public JSlider jSWahrscheinlichkeit = new JSlider(0,1000); public JTextField jTLeben = new JTextField(); public JTextField jTGeburt = new JTextField(); public JTextField jTSterben = new JTextField(); public JTextField jTBreite = new JTextField(""+this.jSBreite.getValue(),12); public JTextField jTHoehe = new JTextField(""+this.jSHoehe.getValue(),12); public JTextField jTVerzoegerung = new JTextField(""+this.jSVerzoegerung.getValue(),12); public JTextField jTWahrscheinlichkeit = new JTextField(""+this.jSWahrscheinlichkeit.getValue(),12); public JCheckBox jCBUmbruch = new JCheckBox("Umbruch",false); public JCheckBox jCBZufall = new JCheckBox("Zufallsbelegung",false); private JButton jBStart = new JButton("Start"); int fensterBreite = 600; int fensterHoehe = 500; /** * Der Konstruktor des Sicht-Objekts * */ public Gui(Wertuebergabe wertuebergabe) { try { jbInit(wertuebergabe); } catch (Exception ex) { ex.printStackTrace(); } } /** * die Methode ersetzt den Konstruktor, da sie seine Aufgaben erledigt, * und wird durch diesen aufgerufen * * */ private void jbInit(Wertuebergabe lebensraum) throws Exception { setDefaultCloseOperation(EXIT_ON_CLOSE); Container cp = getContentPane(); this.setTitle("Zellvermehrung"); cp.setSize(fensterBreite,fensterHoehe); cp.setLayout(new BorderLayout()); this.setLocation(0,30); this.setResizable(false); JPanel pnlRoot = new JPanel(new BorderLayout()); pnlRoot.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10)); JPanel pnlJLabel = new JPanel(new GridLayout(7,1,5,5)); pnlJLabel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10)); pnlJLabel.add(jLBreite); pnlJLabel.add(jLHoehe); pnlJLabel.add(jLVerzoegerung); pnlJLabel.add(jLLeben); pnlJLabel.add(jLGeburt); pnlJLabel.add(jLSterben); pnlJLabel.add(jLWahrscheinlichkeit); JPanel pnlEingabe = new JPanel(new GridLayout(7,1,5,5)); pnlJLabel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10)); pnlEingabe.add(jSBreite); pnlEingabe.add(jSHoehe); pnlEingabe.add(jSVerzoegerung); pnlEingabe.add(jTLeben); pnlEingabe.add(jTGeburt); pnlEingabe.add(jTSterben); pnlEingabe.add(jSWahrscheinlichkeit); JPanel pnlAusgabe = new JPanel(new GridLayout(7,1,5,5)); pnlJLabel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10)); pnlAusgabe.add(jTBreite); pnlAusgabe.add(jTHoehe); pnlAusgabe.add(jTVerzoegerung); pnlAusgabe.add(jCBUmbruch); pnlAusgabe.add(jLPlatzhalter); pnlAusgabe.add(jCBZufall); pnlAusgabe.add(jTWahrscheinlichkeit); pnlRoot.add(pnlJLabel, BorderLayout.WEST); pnlRoot.add(pnlEingabe, BorderLayout.CENTER); pnlRoot.add(pnlAusgabe, BorderLayout.EAST); pnlRoot.add(jBStart, BorderLayout.SOUTH); jSBreite.setMinorTickSpacing(20); jSBreite.setMajorTickSpacing(100); jSBreite.setPaintTicks(true); jSHoehe.setMinorTickSpacing(10); jSHoehe.setMajorTickSpacing(50); jSHoehe.setPaintTicks(true); jSVerzoegerung.setMinorTickSpacing(50); jSVerzoegerung.setMajorTickSpacing(100); jSVerzoegerung.setPaintTicks(true); jSWahrscheinlichkeit.setMinorTickSpacing(50); jSWahrscheinlichkeit.setMajorTickSpacing(100); jSWahrscheinlichkeit.setPaintTicks(true); cp.add(pnlRoot); this.addWindowListener(lebensraum); jBStart.addActionListener(lebensraum); jSBreite.addChangeListener(lebensraum); jSHoehe.addChangeListener(lebensraum); jSVerzoegerung.addChangeListener(lebensraum); jSWahrscheinlichkeit.addChangeListener(lebensraum); jCBZufall.addItemListener(lebensraum); jTBreite.addActionListener(lebensraum); jTHoehe.addActionListener(lebensraum); jTVerzoegerung.addActionListener(lebensraum); jTWahrscheinlichkeit.addActionListener(lebensraum); pack(); setVisible(true); } public JButton getjBStart() { return jBStart; } public JSlider getJSBreite(){ return jSBreite; } public JSlider getJSHoehe(){ return jSHoehe; } public JSlider getJSVerzoegrung(){ return jSVerzoegerung; } public JSlider getJSWahrscheinlichkeit(){ return jSWahrscheinlichkeit; } }

package gui; import java.awt.Canvas; import java.awt.Color; import java.awt.Component; import java.awt.Graphics; import java.awt.GridBagConstraints; import java.awt.GridBagLayout; import java.awt.Image; import java.awt.Insets; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.awt.event.MouseAdapter; import java.awt.event.MouseEvent; import java.awt.event.MouseListener; import java.awt.event.MouseMotionListener; import java.awt.event.WindowAdapter; import java.awt.event.WindowEvent; import java.util.Arrays; import java.util.Enumeration; import java.util.Hashtable; import java.util.TreeSet; import java.util.Vector; import javax.swing.*; import start.Start; import berechnung.LebendeZellen; import berechnung.Wertuebergabe; import berechnung.Regeln; import berechnung.SterbendeZellen; import berechnung.ToteZellen; import interfaces.InterfaceZellen; /** * * @author MilkToast * *In dieser Klasse werden die Zeichenfläche erstellt, sowie die restlichen Komponenten *die dem Benutzer die geforderten Buttons und Textfelder anzeigen. Auch werden hier die *MEthoden erstellt die die Simulation so ablaufen lasssen, wie es in der aufgabe gefordert war. */ public class Grafik extends JFrame implements ActionListener, Runnable { /** * * Die Klasse Canvas erstellt eine Zeichenfläche, auf der die Zellen gezeichnet werden * */ public class MyCanvas extends Canvas implements MouseMotionListener{ private int canvasBreite, canvasHoehe,wahrscheinlichkeit, xalt,xneu,yalt,yneu; private InterfaceZellen[][] canZellen; private int zellenLaenge; private Image img; private Graphics gr; boolean umbruch, zufall; int x = 0; int y = 0; boolean zellenSetzen; public MyCanvas(int breite, int hoehe,boolean zufall,int wahrscheinlichkeit) { super(); setTitle("Lebensraum"); setBackground(Color.WHITE); setBounds(0,0,900,450); this.canvasBreite = breite; this.canvasHoehe = hoehe; this.umbruch = umbruch; this.zufall = zufall; this.wahrscheinlichkeit = wahrscheinlichkeit; this.addMouseMotionListener(this); this.zellenLaenge = this.getZellenLaenge(); xalt = 0; yneu = 0; xneu = 0; yalt = 0; zellenSetzen = false; } /** * Die Methode Paint zeichnet die Zellen so auf die Zeichenfläche, wie es vom * Benutzer eingestellt worden ist. */ public void paint(Graphics g){ this.canZellen = getFeld(); for (int i = 0; i < hoehe; i++) { for (int j = 0; j < breite; j++) { if(zufall == true){ if (this.canZellen[j][i] != null) { g.setColor(this.canZellen[j][i].getFarbe()); g.fillRect(j * zellenLaenge, i * zellenLaenge, zellenLaenge - 1, zellenLaenge - 1); } } else{ this.canZellen[j][i] = new ToteZellen(); g.setColor(this.canZellen[j][i].getFarbe()); g.drawRect(j * zellenLaenge, i * zellenLaenge, zellenLaenge - 1, zellenLaenge - 1); } } } } /** * Verhindert das Flackern der Animation */ public void update(Graphics g) { if (img == null){ img = createImage(this.getWidth(), this.getHeight()); } gr = img.getGraphics(); gr.setColor(getBackground()); gr.fillRect(0, 0, this.getWidth(), this.getHeight()); gr.setColor(getForeground()); paint(gr); g.drawImage(img, 0, 0, this); } /** * Methode rechnet die Größe der darzustellenden Zellen aus * */ public int getZellenLaenge() { int x = (int)(900 / this.canvasBreite); int y = (int)(450 / this.canvasHoehe); return (Math.min(x, y)); } public void mouseMoved (MouseEvent e) { this.zellenSetzen = false; this.xalt = e.getX(); this.yalt = e.getY(); } public void mouseDragged(MouseEvent e) { if (this.zellenSetzen) { this.xalt = xneu; this.yalt = yneu; } else { this.xalt = e.getX(); this.yalt = e.getY(); } this.zellenSetzen = true; this.xneu = e.getX(); this.yneu = e.getY(); } } /** * Sorgt dafür, dass das Fenster geschlossen wird und der Benutzer erneut * eine Simulation ausführen kann * */ public class MyWindowListener extends WindowAdapter { public void windowClosed(WindowEvent e) { } public void windowClosing(WindowEvent e) { e.getWindow().dispose(); } } /** * Legt die Parameter für das GridBagLayout fest * * @param c * @param x * @param y * @param width * @param height * @param fill * @param anchor * @param weightx * @param weighty * @param it * @param il * @param ib * @param ir */ private void placeItem(Component c, int x, int y, int width, int height, int fill, int anchor, int weightx, int weighty, int it, int il, int ib, int ir) { GridBagConstraints constraints = new GridBagConstraints(); constraints.gridx = x; constraints.gridy = y; constraints.gridwidth = width; constraints.gridheight = height; constraints.fill = fill; constraints.anchor = anchor; constraints.weightx = weightx; constraints.weighty = weighty; constraints.insets = new Insets(it, il, ib, ir); GridLayout.setConstraints(c, constraints); add(c); } private GridBagLayout GridLayout = new GridBagLayout(); private JButton jBStart = new JButton("Start"); private JButton jBSchritt = new JButton("Schritt"); private JButton jBEnde = new JButton("Ende"); private JLabel jLGeneration = new JLabel("Generation"); private JLabel jLAlterMomentan = new JLabel("max. Alter mom"); private JLabel jLAlterGesamt = new JLabel("max Alter ges"); public JTextField jTGeneration = new JTextField(); private JTextField jTAlterMomentan = new JTextField(); private JTextField jTAlterGesamt = new JTextField(); private InterfaceZellen[][] intLeb; Gui gui; Regeln regeln; private MyCanvas canvas; private int breite, hoehe, verzoegerung,wahrscheinlichkeit,anzahlLebenderZellen; String leben,geburt,generation; boolean zufall; public int aktGeneration = 0; private Thread simulation; TreeSet<Integer> set = new TreeSet<Integer>(); public Grafik(int breite, int hoehe, int verzoegerung,int wahrscheinlichkeit, String leben, String geburt, String generation,boolean zufall, int anzahlLebenderZellen) { this.breite = breite; this.hoehe = hoehe; this.verzoegerung = verzoegerung; this.wahrscheinlichkeit = wahrscheinlichkeit; this.leben = leben; this.geburt = geburt; this.intLeb = new InterfaceZellen[this.breite][this.hoehe]; this.zufall= zufall; this.anzahlLebenderZellen = anzahlLebenderZellen; this.generation = generation; regeln = new Regeln(leben,geburt,generation); this.canvas = new MyCanvas(this.breite, this.hoehe,this.zufall,this.wahrscheinlichkeit); this.addWindowListener(new MyWindowListener()); this.setLayout(GridLayout); this.setBackground(Color.LIGHT_GRAY); this.setResizable(false); this.setSize(1020,530); this.placeItem(this.canvas, 0, 0, 1, 18, GridBagConstraints.NONE, GridBagConstraints.WEST, 1, 1, 5, 10, 5, 10); this.placeItem(this.jBStart, 1, 0, 1, 1, GridBagConstraints.HORIZONTAL, GridBagConstraints.WEST, 1, 1, 5, 10, 5, 10); this.placeItem(this.jBSchritt, 1, 1, 1, 1, GridBagConstraints.HORIZONTAL, GridBagConstraints.WEST, 1, 1, 5, 10, 5, 10); this.placeItem(this.jBEnde, 1, 2, 1, 1, GridBagConstraints.HORIZONTAL, GridBagConstraints.WEST, 1, 1, 5, 10, 5, 10); this.placeItem(this.jLGeneration, 1, 3, 1, 1, GridBagConstraints.HORIZONTAL, GridBagConstraints.WEST, 1, 1, 5, 10, 0, 10); this.placeItem(this.jTGeneration, 1, 4, 1, 1, GridBagConstraints.HORIZONTAL, GridBagConstraints.WEST, 1, 1, 0, 10, 5, 10); this.placeItem(this.jLAlterMomentan, 1, 5, 1, 1, GridBagConstraints.HORIZONTAL, GridBagConstraints.WEST, 1, 1, 5, 10, 0, 10); this.placeItem(this.jTAlterMomentan, 1, 6, 1, 1, GridBagConstraints.HORIZONTAL, GridBagConstraints.WEST, 1, 1, 0, 10, 5, 10); this.placeItem(this.jLAlterGesamt, 1, 7, 1, 1, GridBagConstraints.HORIZONTAL, GridBagConstraints.WEST, 1, 1, 5, 10, 0, 10); this.placeItem(this.jTAlterGesamt, 1, 8, 1, 1, GridBagConstraints.HORIZONTAL, GridBagConstraints.WEST, 1, 1, 0, 10, 5, 10); this.jBStart.addActionListener(this); this.jBSchritt.addActionListener(this); this.jBEnde.addActionListener(this); this.jTGeneration.addActionListener(this); this.jTAlterGesamt.addActionListener(this); this.jTAlterMomentan.addActionListener(this); this.zufallsPosition(this.anzahlLebenderZellen); this.setVisible(true); } /** * Führt beim betätigen der Buttons die geforderten Aktionen aus. * * */ public void actionPerformed(ActionEvent e) { if (e.getActionCommand()=="Schritt") { this.nachbarschaft(); this.generation(); this.ermittleAlter(); this.aktGeneration++; String sGeneration = Integer.toString(this.aktGeneration); jTGeneration.setText(sGeneration); String sAlterGesamt = Integer.toString(this.set.last()); jTAlterGesamt.setText(sAlterGesamt); canvas.repaint(); } else if (e.getActionCommand() == "Start") { this.jBStart.setActionCommand("Stop"); this.jBStart.setLabel("Stop"); this.jBSchritt.setEnabled(false); if (simulation == null) { simulation = new Thread(this); simulation.start(); } } else if (e.getActionCommand() == "Stop") { this.jBStart.setActionCommand("Start"); this.jBStart.setLabel("Start"); this.jBSchritt.setEnabled(true); if (simulation != null) { simulation.stop(); simulation = null; } } else if (e.getActionCommand() == "Ende") { simulation = null; this.aktGeneration = 0; this.dispose(); } } /** * Methode verteilt die Zellen zufällig auf der Zeichenfläche * */ public void zufallsPosition(int belegung) { int toteZellen = this.breite * this.hoehe; toteZellen -= belegung; for (int i = 0; i < belegung; i++) { int x = (int) (Math.random() * breite); int y = (int) (Math.random() * hoehe); while (intLeb[x][y] != null) { x = (int) (Math.random() * breite); y = (int) (Math.random() * hoehe); } this.intLeb[x][y] = new LebendeZellen(0); } for(int i = 0; i < toteZellen;i++) { int x = (int) (Math.random() * breite); int y = (int) (Math.random() * hoehe); while (intLeb[x][y] != null) { x = (int) (Math.random() * breite); y = (int) (Math.random() * hoehe); } this.intLeb[x][y] = new ToteZellen(); } } public InterfaceZellen[][] getFeld() { return this.intLeb; } /** * Wichtigste Methode im Porjekt. Überprüft für jedes Feld die Nachbarschaft und führt dann * die vom Benutzer gewählten Regeln aus. * */ public void nachbarschaft() { Hashtable<Integer, Integer> leben = new Hashtable<Integer, Integer>(regeln.getLebensregel()); Hashtable<Integer, Integer> geburt = new Hashtable<Integer, Integer>(regeln.getGeburtenregel()); this.generation = regeln.getGeneration(); this.intLeb = getFeld(); for(int i = 0; i < this.breite;i++) { for(int j = 0; j < this.hoehe; j++){ Integer zaehlerLeben = 0; for (int x = 0; x <= 8; x++) { int nachBreite = i; int nachHoehe = j; if (x == 1) { if (nachBreite > 0 && nachHoehe > 0) { nachBreite -= 1; nachHoehe -= 1; if(intLeb[nachBreite][nachHoehe].getZustand().equals("lebend")) { zaehlerLeben++; } } } else if (x == 2) { if (nachHoehe > 0) { nachHoehe -= 1; if(intLeb[nachBreite][nachHoehe].getZustand().equals("lebend")) { zaehlerLeben++; } } } else if (x == 3) { if (nachBreite < breite - 1 && nachHoehe > 0) { nachBreite += 1; nachHoehe -= 1; if(intLeb[nachBreite][nachHoehe].getZustand().equals("lebend")) { zaehlerLeben++; } } } else if (x == 4) { if (nachBreite < breite - 1) { nachBreite += 1; if(intLeb[nachBreite][nachHoehe].getZustand().equals("lebend")) { zaehlerLeben++; } } } else if (x == 5) { if (nachBreite < breite - 1 && nachHoehe < hoehe - 1) { nachBreite += 1; nachHoehe += 1; if(intLeb[nachBreite][nachHoehe].getZustand().equals("lebend")) { zaehlerLeben++; } } } else if (x == 6) { if (nachHoehe < hoehe - 1) { nachHoehe += 1; if(intLeb[nachBreite][nachHoehe].getZustand().equals("lebend")) { zaehlerLeben++; } } } else if (x == 7) { if (nachBreite > 0 && nachHoehe < hoehe - 1) { nachBreite -= 1; nachHoehe += 1; if(intLeb[nachBreite][nachHoehe].getZustand().equals("lebend")) { zaehlerLeben++; } } } else if (x == 8) { if (nachBreite > 0) { nachBreite -= 1; if(intLeb[nachBreite][nachHoehe].getZustand().equals("lebend")) { zaehlerLeben++; } } } } for(int c = 0; c <= leben.size(); c++){ if(leben.get(c) != null){ if(leben.get(c) == zaehlerLeben){ if(this.intLeb[i][j].getZustand().equals("lebend")){ this.intLeb[i][j].setLeben(true); this.intLeb[i][j].setSterben(false); zaehlerLeben--; break; } } if(leben.get(c) != zaehlerLeben){ if(this.intLeb[i][j].getZustand().equals("lebend")){ this.intLeb[i][j].setLeben(false); this.intLeb[i][j].setSterben(true); } if(this.intLeb[i][j].getZustand().equals("tot")) { this.intLeb[i][j].setLeben(false); this.intLeb[i][j].setSterben(false); } } } } for(int d =0; d < geburt.size(); d++){ if(geburt.get(d)!= null){ if(geburt.get(d) == zaehlerLeben){ if(this.intLeb[i][j].getZustand().equals("tot")){ this.intLeb[i][j].setLeben(true); this.intLeb[i][j].setSterben(false); zaehlerLeben--; break; } } } } } } for(int k = 0; k < this.breite;k++){ for(int l =0; l < this.hoehe; l++){ if(this.intLeb[k][l].getLeben()== true && this.intLeb[k][l].getSterben() == false){ if(this.intLeb[k][l].getZustand()=="lebend"){ this.intLeb[k][l].setRotBlau(); this.intLeb[k][l].erhoeheAlter(); } else{ this.intLeb[k][l].setRotBlau(); this.intLeb[k][l] = new LebendeZellen(0); } } else if(this.intLeb[k][l].getSterben()==true && this.intLeb[k][l].getLeben()==false){ if(this.intLeb[k][l].getZustand()=="lebend"){ int aktAlter = this.intLeb[k][l].getAlter(); this.intLeb[k][l] = new SterbendeZellen(0,aktAlter); this.intLeb[k][l].setRotBlau(); this.intLeb[k][l].erhoeheAlter(); } else{ this.intLeb[k][l].setRotBlau(); this.intLeb[k][l].erhoeheGeneration(); this.intLeb[k][l].erhoeheAlter(); } } else{ this.intLeb[k][l] = new ToteZellen(); } } } } /** * Diese Methode lässt sterbende Zellen, nachdem Sie eine bestimmte Anzahl von * Generationen im Zustand sterbend verblieben sind, zu neuen toten Zellen werden. */ public void generation(){ for(int i = 0; i < this.breite; i++){ for(int j = 0; j < this.hoehe; j++){ int gen = Integer.parseInt(this.generation); if(this.intLeb[i][j].getZustand().equals("sterbend")&& this.intLeb[i][j].getGeneration()==gen){ this.intLeb[i][j] = new ToteZellen(); } } } } public void ermittleAlter(){ for(int i = 0; i < this.breite; i++){ for(int j = 0; j < this.hoehe; j++){ int aktAlter = this.intLeb[i][j].getAlter(); this.set.add(aktAlter); } } } /** * Methode wird ausgeführt, wenn auf den Button Start gedrückt wird. Sie startet * den Thread und lässt diesen solange "schlafen" wie die Verzögerung vom Benutzer eingestellt wurde. */ public void run() { while (true) { this.nachbarschaft(); this.aktGeneration++; this.generation(); this.ermittleAlter(); String sGeneration = Integer.toString(this.aktGeneration); jTGeneration.setText(sGeneration); String sAlterGesamt = Integer.toString(this.set.last()); jTAlterGesamt.setText(sAlterGesamt); canvas.repaint(); try { Thread.sleep(this.verzoegerung); } catch (InterruptedException ex) { } } } public JButton getJBStart() { return jBStart; } public void setJBStart(JButton start) { jBStart = start; } public JButton getJBSchritt() { return jBSchritt; } public void setJBSchritt(JButton schritt) { jBSchritt = schritt; } public JButton getJBEnde() { return jBEnde; } public void setJBEnde(JButton ende) { jBEnde = ende; } public int getAktGeneration() { return aktGeneration; } public void setAktGeneration(int aktGeneration) { this.aktGeneration = aktGeneration; } }

package berechnung; import java.awt.Color; /** * Jede neue erstellte LebendeZelle erbt von der abstrakten Klasse "ZellenAllgemein" und * implementiert das "InterfaceZellen". Die Lebenden Zellen erhahlten einen zustand, eine zustandsFarbe * und ein alter. Die Varialbe "lebt" ist ein boolean, womit der Status der Zelle gesetzt wird, genau * das gleiche passiert bei dem boolean "stirbt". Diese beiden boolean sind dafür da um eine * lebende Zelle genauer zu kennzeichnen. Falls diese in der nächsten Generation sterben sollten, werden die * boolean so gesetzt , damit das Programm diese in der nächsten Generation als sterbende Zellen * erkennen kann. * Desweitern werden für alle Variablen die Getter und Setter angelegt. */ import interfaces.InterfaceZellen; public class LebendeZellen extends ZellenAllgemein implements InterfaceZellen { public LebendeZellen(int alter){ zustand = "lebend"; zustandsFarbe = new Color(255,0,0); lebt = true; this.alter = alter; stirbt = false; } @Override public int getAlter() { // TODO Auto-generated method stub return this.alter; } @Override public Color getFarbe() { // TODO Auto-generated method stub return zustandsFarbe; } @Override public String getZustand() { // TODO Auto-generated method stub return zustand; } @Override public void setAlter(int alter) { this.alter = alter; // TODO Auto-generated method stub } @Override public void setFarbe(Color farbe) { // TODO Auto-generated method stub } @Override public void setZustand(String zustand) { // TODO Auto-generated method stub } @Override public boolean getLeben() { // TODO Auto-generated method stub return this.lebt; } @Override public void setLeben(boolean lebt) { this.lebt = lebt; // TODO Auto-generated method stub } @Override public boolean getSterben() { // TODO Auto-generated method stub return this.stirbt; } @Override public void setSterben(boolean stirbt) { this.stirbt = stirbt; // TODO Auto-generated method stub } @Override public void setGeneration(int generation) { // TODO Auto-generated method stub } @Override public void erhoeheGeneration() { // TODO Auto-generated method stub } @Override public int getGeneration() { // TODO Auto-generated method stub return 0; } /** * Diese Methode erhöht das Alter der Zellen und setzt den Rotanteil bei steigendem Alter * herab und den Blauanteil herauf. */ @Override public void erhoeheAlter() { this.alter++; this.rotanteil -= this.alter; this.blauanteil += this.alter; if(this.rotanteil < 0){ this.zustandsFarbe = new Color(0,0,255); } else{ this.zustandsFarbe = new Color(this.rotanteil,0,this.blauanteil); } } /** * Diese Methode setzt den Rot und Blauanteil einer lebenden Zellen bei ihrer Geburt * auf den Standardwert. Diese Werte werden dann mit steigendem Alter umgerechnet. */ @Override public void setRotBlau() { this.rotanteil = 255; this.blauanteil = 0; } }

package berechnung; import java.sql.Array; import java.util.Hashtable; /** * @author MilkToast * * Die Regeln Methode fängt die Regeln für das Überleben, die Geburt und das Sterben der * Zellen ab. Die vom Benutzer getätigten Eingaben werden im Fall der Überlebens und * Geburtenregeln in ihre einzelnen Ziffern aufgeteilt und jede Ziffer wird dann * in einem Hashtable abgespeichert. Die so aufbereiteten Daten können dann vom Hauptprogramm * benutzt werden */ public class Regeln { String leben,geburt,generation; Hashtable<Integer, Integer> lebensregel = new Hashtable<Integer, Integer>(); Hashtable<Integer, Integer> geburtenregel = new Hashtable<Integer, Integer>(); char []lebenRegel; /** * Der Konstruktor der Klasse, bekommt die Eingaben des Benutzers und * führt für die Überlebensregel und die Geburtenregel die Methode * "trennen()" durch. * * */ public Regeln(String leben, String geburt, String generation){ this.leben = leben; this.geburt = geburt; this.generation = generation; trennen(leben,geburt); } /** * Die Methode "trennen()" geht das Eingabefeld für die Überlebensregel und * die Geburtregel Zeichen für Zeichen durch und speichert die so erhaltenen * Werte in einem Hashtable ab. * * @param leben * @param geburt */ public void trennen(String leben,String geburt){ for(int i = 0; i < leben.length();i++) { int wertLeben = Integer.parseInt(""+leben.charAt(i)); lebensregel.put(i, wertLeben); } for(int j = 0; j < geburt.length();j++) { int wertGeburt = Integer.parseInt(""+geburt.charAt(j)); geburtenregel.put(j, wertGeburt); } } /** * Dies sind die Getter und Setter Methoden. */ public String getLeben() { return leben; } public void setLeben(String leben) { this.leben = leben; } public String getGeburt() { return geburt; } public void setGeburt(String geburt) { this.geburt = geburt; } public String getGeneration() { return generation; } public void setTot(String generation) { this.generation = generation; } public Hashtable<Integer, Integer> getLebensregel() { //System.out.println(lebensregel+" Lebensregel"); return lebensregel; } public void setLebensregel(Hashtable<Integer, Integer> lebensregel) { this.lebensregel = lebensregel; } public Hashtable<Integer, Integer> getGeburtenregel() { return geburtenregel; } public void setGeburtenregel(Hashtable<Integer, Integer> geburtenregel) { this.geburtenregel = geburtenregel; } }

package berechnung; import java.awt.Color; import interfaces.InterfaceZellen; /** * Jede neue erstellte sterbende Zelle erbt von der abstrakten Klasse "ZellenAllgemein" und * implementiert das "InterfaceZellen". Die sterbenden Zellen erhahlten einen zustand, eine zustandsFarbe * und ein alter. Die Varialbe "lebt" ist ein boolean, womit der Status der Zelle gesetzt wird, genau * das gleiche passiert bei dem boolean "stirbt". Diese beiden boolean sind dafür da um eine * lebende Zelle genauer zu kennzeichnen. Falls diese in der nächsten Generation leben sollten, werden die * boolean so gesetzt , damit das Programm diese in der nächsten Generation als lebende Zellen * erkennen kann. * Desweitern werden für alle Variablen die Getter und Setter angelegt. */ public class SterbendeZellen extends ZellenAllgemein implements InterfaceZellen { public SterbendeZellen(int generation, int alter) { zustand = "sterbend"; zustandsFarbe = new Color(255,0,0); this.alter = alter; this.generation= generation; lebt = false; stirbt = true; } @Override public int getAlter() { // TODO Auto-generated method stub return this.alter; } @Override public Color getFarbe() { // TODO Auto-generated method stub return zustandsFarbe; } @Override public String getZustand() { // TODO Auto-generated method stub return zustand; } @Override public void setAlter(int alter) { this.alter = alter; // TODO Auto-generated method stub } @Override public void setFarbe(Color farbe) { // TODO Auto-generated method stub } @Override public void setZustand(String zustand) { // TODO Auto-generated method stub } @Override public boolean getLeben() { // TODO Auto-generated method stub return this.lebt; } @Override public void setLeben(boolean lebt) { this.lebt = lebt; // TODO Auto-generated method stub } @Override public boolean getSterben() { // TODO Auto-generated method stub return this.stirbt; } @Override public void setSterben(boolean stirbt) { this.stirbt = stirbt; // TODO Auto-generated method stub } public void setGeneration(int generation){ this.generation = generation; } /** * Erhöht bei jedem Aufruf die Generation um 1. */ public void erhoeheGeneration(){ this.generation++; } public int getGeneration(){ return this.generation; } /** * Diese Methode erhöht das Alter der Zellen und setzt den Rotanteil bei steigendem Alter * herab und den Blauanteil herauf. */ @Override public void erhoeheAlter() { this.alter++; this.rotanteil -= this.alter; this.blauanteil += this.alter; if(this.rotanteil < 0){ this.zustandsFarbe = new Color(0,0,255); } else{ this.zustandsFarbe = new Color(this.rotanteil,0,this.blauanteil); } // TODO Auto-generated method stub } /** * Diese Methode setzt den Rot und Blauanteil einer lebenden Zellen bei ihrer Geburt * auf den Standardwert. Diese Werte werden dann mit steigendem Alter umgerechnet. */ @Override public void setRotBlau() { this.rotanteil = 255; this.blauanteil = 0; // TODO Auto-generated method stub } }

package berechnung; import java.awt.Color; import interfaces.InterfaceZellen; /** * Jede neue erstellte tote Zelle erbt von der abstrakten Klasse "ZellenAllgemein" und * implementiert das "InterfaceZellen". Die toten Zellen erhahlten einen zustand, eine zustandsFarbe * und ein alter. Die Varialbe "lebt" ist ein boolean, womit der Status der Zelle gesetzt wird, genau * das gleiche passiert bei dem boolean "stirbt". Diese beiden boolean sind dafür da um eine * lebende Zelle genauer zu kennzeichnen. * Desweitern werden für alle Variablen die Getter und Setter angelegt. */ public class ToteZellen extends ZellenAllgemein implements InterfaceZellen { public ToteZellen(){ zustand = "tot"; alter = 0; zustandsFarbe = Color.WHITE; lebt = false; stirbt = false; } public String getZustand() { // TODO Auto-generated method stub return this.zustand; } @Override public int getAlter() { // TODO Auto-generated method stub return 0; } @Override public Color getFarbe() { // TODO Auto-generated method stub return this.zustandsFarbe; } @Override public void setAlter(int alter) { // TODO Auto-generated method stub } @Override public void setFarbe(Color farbe) { // TODO Auto-generated method stub } @Override public void setZustand(String zustand) { // TODO Auto-generated method stub } @Override public boolean getLeben() { // TODO Auto-generated method stub return this.lebt; } @Override public void setLeben(boolean lebt) { this.lebt = lebt; // TODO Auto-generated method stub } @Override public boolean getSterben() { // TODO Auto-generated method stub return this.stirbt; } @Override public void setSterben(boolean stirbt) { this.stirbt = stirbt; // TODO Auto-generated method stub } @Override public void setGeneration(int generation) { // TODO Auto-generated method stub } @Override public void erhoeheGeneration() { // TODO Auto-generated method stub } @Override public int getGeneration() { // TODO Auto-generated method stub return 0; } @Override public void erhoeheAlter() { // TODO Auto-generated method stub } @Override public void setRotBlau() { // TODO Auto-generated method stub } }

package berechnung; import interfaces.InterfaceZellen; import java.awt.Canvas; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.awt.event.ItemEvent; import java.awt.event.ItemListener; import java.awt.event.WindowEvent; import java.awt.event.WindowListener; import javax.swing.JSlider; import javax.swing.JTextField; import javax.swing.event.ChangeEvent; import javax.swing.event.ChangeListener; import gui.Grafik; import gui.Gui; /** * * @author MilkToast * * Die Klasse Wertuebergabe reagiert auf das drücken des Startknopfes in der Gui. Hier werden * alle Werte die der Benutzer eingeben hat an die entsprechenden Klassen weitergegeben. * */ public class Wertuebergabe implements ActionListener, WindowListener, ChangeListener, ItemListener { Gui gui; Grafik grafik; int breite, hoehe, verzoegerung, wahrscheinlichkeit,anzahlLebenderZellen; public InterfaceZellen[][] zellen; boolean state; String leben, sterben, geburt; public void actionPerformed(ActionEvent e) { gui.jSBreite.setValue( Integer.parseInt(gui.jTBreite.getText()) ); gui.jSHoehe.setValue( Integer.parseInt(gui.jTHoehe.getText()) ); gui.jSVerzoegerung.setValue( Integer.parseInt(gui.jTVerzoegerung.getText()) ); gui.jSWahrscheinlichkeit.setValue( Integer.parseInt(gui.jTWahrscheinlichkeit.getText()) ); this.zellen = new InterfaceZellen[this.gui.jSBreite.getValue()][this.gui.jSHoehe.getValue()]; if(e.getSource()== gui.getjBStart()){ wahrscheinlichkeit = Integer.parseInt(gui.jTWahrscheinlichkeit.getText()); anzahlLebenderZellen = zellenErstellen(wahrscheinlichkeit); new Grafik(this.gui.jSBreite.getValue(),this.gui.jSHoehe.getValue() ,this.gui.jSVerzoegerung.getValue(),this.gui.jSWahrscheinlichkeit.getValue(), this.gui.jTLeben.getText(), this.gui.jTGeburt.getText(), this.gui.jTSterben.getText(),this.state,anzahlLebenderZellen); } } /** * Methode die auf das bewegen der JSlider reagiert. */ public void stateChanged(ChangeEvent e) { breite = gui.getJSBreite().getValue(); String sBreite = Integer.toString(breite); gui.jTBreite.setText(sBreite); hoehe = gui.getJSHoehe().getValue(); String sHoehe = Integer.toString(hoehe); gui.jTHoehe.setText(sHoehe); verzoegerung = gui.getJSVerzoegrung().getValue(); String sVerzoegerung = Integer.toString(verzoegerung); gui.jTVerzoegerung.setText(sVerzoegerung); wahrscheinlichkeit = gui.getJSWahrscheinlichkeit().getValue(); String sWahrscheinlichkeit = Integer.toString(wahrscheinlichkeit); gui.jTWahrscheinlichkeit.setText(sWahrscheinlichkeit); // TODO Auto-generated method stub } public void setView(Gui setzeSicht) { gui = setzeSicht; } @Override public void windowActivated(WindowEvent arg0) { // TODO Auto-generated method stub } @Override public void windowClosed(WindowEvent arg0) { // TODO Auto-generated method stub } @Override public void windowClosing(WindowEvent arg0) { // TODO Auto-generated method stub } @Override public void windowDeactivated(WindowEvent arg0) { // TODO Auto-generated method stub } @Override public void windowDeiconified(WindowEvent arg0) { // TODO Auto-generated method stub } @Override public void windowIconified(WindowEvent arg0) { // TODO Auto-generated method stub } @Override public void windowOpened(WindowEvent arg0) { // TODO Auto-generated method stub } /** * Diese Methode erstellt die Menge an lebenden Zellen, die vom * Benutzer über das Feld Wahrscheinlichkeit angegeben werden. * * */ public int zellenErstellen(int wahrscheinlichkeit) { int breite = gui.jSBreite.getValue(); int hoehe = gui.jSHoehe.getValue(); double gesamt = breite*hoehe; gesamt/=100; double prozent = wahrscheinlichkeit/=10; double leben = gesamt*=prozent; int lebenGerundet = (int)Math.round(leben); return lebenGerundet; } @Override /** * Methode die auf das aktivieren der Checkbox Zufall reagiert. * */ public void itemStateChanged(ItemEvent i) { state = gui.jCBZufall.isSelected(); gui.jCBZufall.setSelected(state); if(state == false) { System.out.println("jojo"); gui.jSWahrscheinlichkeit.setEnabled(false); gui.jTWahrscheinlichkeit.setEditable(false); } else { gui.jSWahrscheinlichkeit.setEnabled(true); gui.jTWahrscheinlichkeit.setEnabled(true); gui.jTWahrscheinlichkeit.setEditable(true); } } }

Game of Life

Die GUI

Der Lebensraum

Softwarearchitektur

Der Quellcode

Interessante Verhaltensmuster