Advertisement
Guest User

asdfconway123

a guest
May 4th, 2016
82
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 24.86 KB | None | 0 0
  1. import com.sun.xml.internal.ws.policy.privateutil.PolicyUtils;
  2.  
  3. import java.sql.*;
  4. import java.util.Random;
  5. import java.util.Scanner;
  6. import java.io.*;
  7.  
  8. /**
  9.  * Created by activeagent on 02.05.16.
  10.  */
  11.  
  12.  
  13. class Zellen {
  14.     int feldGroesseX;                                                                                                   //Variable zur Einstellung der Feldgröße
  15.     int feldGroesseY;
  16.  
  17.     public void spielFeld(int berechGr, boolean defGr){
  18.         System.out.println("hallo!!"+defGr);
  19.  
  20.         if (defGr==true){
  21.             feldGroesseX=berechGr;
  22.             feldGroesseY=berechGr;
  23.             System.out.println("test defgr =true");
  24.         }
  25.  
  26.         else{
  27.             feldGroesseY=berechGr*10;
  28.             feldGroesseX=berechGr*10;
  29.             System.out.println("defGr=false");
  30.         }
  31.  
  32.     }
  33.  
  34.     boolean[][] zellen = new boolean[feldGroesseY][feldGroesseX];                                                       //Erstellen eines doppelten Boolean Array für den zustand der Zelle true = leben/false=tot
  35.     boolean[][] temp = new boolean[feldGroesseY][feldGroesseX];                                                         //    "                                   für die Zwischenspeicherung des Zustands bei Änderung
  36.  
  37.     Scanner scanner = new Scanner(System.in);
  38.  
  39.     String regeln = scanner.next();                                                                                     //Einlesen der Regeln
  40.     String[] parts = regeln.split("/");                                                                                 //String beim "/" splitten
  41.     String part1 = parts[0];                                                                                            //String-Teil1
  42.     String part2 = parts[1];                                                                                            //String-Teil2
  43.     char[] c = part1.toCharArray();                                                                                     //String-Teil1 in einen CharArray umwandeln
  44.     char[] c0 = part2.toCharArray();                                                                                    //String-Teil2    "
  45.     int [] regelnArray1 = new int[part1.length()];                                                                      //Neuen int Array erstellen mit der länge von dem String-Teil1
  46.     int [] regelnArray2 = new int[part2.length()];                                                                      //          "                                     String-Teil2
  47.  
  48.  
  49.     public void regelnSetzen() {
  50.  
  51.     for (int x = 0; x < c.length; x++) {                                                                                //for-Schleife mit der Anzahl an durchgängen wie lange der Chararray c ist
  52.         regelnArray1[x] = Character.getNumericValue(c[x]);                                                              //in den regelnArray den numerischen Wert der einzelnen einträge im charArray einfügen
  53.     }
  54.     for (int y = 0; y<c0.length;y++){
  55.         regelnArray2[y] = Character.getNumericValue(c0[y]);
  56.     }
  57. }
  58.  
  59.     int generation=0;
  60.  
  61.     public void arrayStartwerte() {                                                                                     //Methode zum setzen der Startwerte der Zellen
  62.         int zufall;                                                                                                     //Zufallszahl
  63.         Random random = new Random();
  64.  
  65.  
  66.         for (int i=0;i<feldGroesseY;i++){                                                                               //Geschachtelte for-Schleife um Werte im Array zu setzen
  67.             for (int j=0;j<feldGroesseX;j++){
  68.                 zufall=random.nextInt(10-0+1)+1;                                                                        //Zufallszahl erstellen für das Festlegen der Startzustände der Zellen
  69.                 if (zufall>=5){                                                                                         //Wenn zufall >=5 ist
  70.                     zellen[i][j]=true;                                                                                  //lebt die Zelle
  71.                 }
  72.                 else {                                                                                                  //Sonst
  73.                     zellen[i][j]=false;                                                                                 //ist die Zelle tot
  74.                 }
  75.             }
  76.         }
  77.     }
  78.  
  79.     public void ausgabeSpielKonsole(String leben, String tot){                                                          //Methode um das Spielfeld auszugeben
  80.  
  81.         System.out.println("Generation: "+generation);                                                                  //Ausgabe in welcher Generation das Spiel sich momentan befindet
  82.         for (int i=0;i<feldGroesseY;i++){                                                                               //Geschachtelte for-Schleife um jedes Feld im Array dur8chzugehen
  83.             System.out.println("test"+feldGroesseX);
  84.             for (int j=0;j<feldGroesseX;j++) {
  85.                 if (zellen[i][j] == true){                                                                              //lebende Zellen werden mit einem (O) dargestellt
  86.                     System.out.print(leben);
  87.                 }
  88.                 else{
  89.                     System.out.print(tot);                                                                              //gestorbene Zellen werden mit einem ( ) dargestellt
  90.                 }
  91.             }
  92.             System.out.println();                                                                                       //Zeilenumbruch nach einer Zeile des Spielfeldes
  93.         }
  94.         generation++;
  95.     }
  96.  
  97.     public void ausgabeSpielTXT(String leben, String tot,String dateiname) throws IOException {
  98.         String filename = "/Users/activeagent/Desktop/Test/"+dateiname;                                                 //Variabler Dateiname(Einträge werden an alte Datei angehängt wenn eine Datei mit dem selben Namen bereits existiert)
  99.         File file = new File(filename);
  100.         file.getParentFile().mkdirs();                                                                                  //Erstellt Ordnerstruktur falls nicht vorhanden
  101.         Writer out;
  102.         out = new BufferedWriter(new FileWriter(filename,true));
  103.         try {
  104.  
  105.             out.append("Generation: " + generation);                                                                    //Ausgabe in welcher Generation das Spiel sich momentan befindet
  106.             out.append("\n");                                                                                           //"\n" für Zeilenumbruch
  107.             for (int i = 0; i < feldGroesseY; i++) {                                                                    //Geschachtelte for-Schleife um jedes Feld im Array durchzugehen
  108.                 for (int j = 0; j < feldGroesseX; j++) {
  109.                     if (zellen[i][j] == true) {
  110.                         out.append(leben);                                                                              //lebende Zellen
  111.                     } else {
  112.                         out.append(tot);                                                                                //gestorbene Zellen
  113.                     }
  114.                 }
  115.                 out.append("\n");                                                                                       //Zeilenumbruch nach einer Zeile des Spielfeldes
  116.             }
  117.             out.close();
  118.  
  119.             generation++;                                                                                               //nächste Generation
  120.         }
  121.  
  122.         catch (IOException e){
  123.  
  124.         }
  125.     }
  126.  
  127.     public void spielZug(){                                                                                             //Methode um einen Spielzug zu simulieren
  128.  
  129.         int testsumme=0;                                                                                                //Testsumme um den neuen Zustand der Zelle festzulegen
  130.         for (int i=0;i<feldGroesseY;i++){                                                                               //Aktuelles Spielfeld wird in dem Array temp gespeichert
  131.             for (int j=0;j<feldGroesseX;j++){
  132.              temp[i][j]=zellen[i][j];
  133.             }
  134.         }
  135.  
  136.         for (int i=0;i<feldGroesseY;i++){
  137.             for (int j=0;j<feldGroesseX;j++){
  138.                 if (j-1>=0){                                                                                            //Prüfen ob j-1 noch im Spielfeld liegt
  139.                     if(i-1>=0){                                                                                         //  "       i-1     "
  140.                         if (temp[i-1][j-1]==true){                                                                      //Prüfen ob die Zelle an dieser Position lebt
  141.                             testsumme=testsumme+1;                                                                      //wenn ja testsumme um 1 erhöhen
  142.                         }
  143.                         if (temp[i][j-1]==true){
  144.                             testsumme=testsumme+1;
  145.                         }
  146.                         if (temp[i-1][j]==true){
  147.                             testsumme=testsumme+1;
  148.                         }
  149.                     }
  150.                     if (i+1<feldGroesseY){
  151.                         if (temp[i+1][j-1]==true){
  152.                             testsumme=testsumme+1;
  153.                         }
  154.                         if (temp[i+1][j]==true){
  155.                             testsumme=testsumme+1;
  156.                         }
  157.                     }
  158.                 }
  159.                 if (j+1<feldGroesseX){
  160.                     if (i-1>=0){
  161.                         if (temp[i-1][j+1]==true){
  162.                             testsumme=testsumme+1;
  163.                         }
  164.                         if (temp[i][j+1]==true){
  165.                             testsumme=testsumme+1;
  166.                         }
  167.                     }
  168.                     if (i+1<feldGroesseY){
  169.                         if (temp[i+1][j+1]){
  170.                             testsumme=testsumme+1;
  171.                         }
  172.                     }
  173.                 }
  174.  
  175.  
  176.  
  177.                 zellen[i][j]=false;                                                                                     //Zellen werden erst auf tot gesetzt
  178.  
  179.                 int regelnMax;                                                                                          //maximale Anzahl an Regeln
  180.  
  181.                 if (regelnArray1.length>regelnArray2.length){                                                           //Wenn regelnArray1 länger als regelnArray2
  182.                     regelnMax=regelnArray1.length;                                                                      //wird regelnArray1 Länge als maximale Anzahl Regeln gesetzt
  183.                 }
  184.  
  185.                 else{                                                                                                   //Sonst (also wenn regelnArray2 länger als regelnArray1 ist oder bei gleichstand)
  186.                     regelnMax=regelnArray2.length;                                                                      //wird regelnArray2 Länge als maximale Anzahl Regeln gesetzt
  187.                 }
  188.  
  189.  
  190.                 for (int l=0;l<regelnMax;l++){                                                                          //for-Schleife mit Anzahl an durchgängen der maximalen Anzahl an Regeln
  191.                     if (l<regelnArray1.length){                                                                         //Schutz vor ArrayIndexOutOfBoundsException()
  192.                         if (testsumme == regelnArray1[l]) {                                                             //Wenn testsumme mit dem Eintrag im regelnArray1 an der Stelle l übereinstimmt
  193.                             zellen[i][j]=true;                                                                          //Zelle wird auf leben gesetzt
  194.                             testsumme=0;                                                                                //testsumme wird vor nächstem Durchgang auf 0 gesetzt
  195.                         }
  196.                     }
  197.  
  198.                     if (l<regelnArray2.length){
  199.                         if (testsumme == regelnArray2[l]){
  200.                             zellen[i][j]=true;
  201.                             testsumme=0;
  202.                         }
  203.                     }
  204.  
  205.                 }
  206.  
  207.                 testsumme=0;
  208.             }
  209.  
  210.         }
  211.  
  212.  
  213.     }
  214.  
  215.     public void gleiterTable(Connection connection,int anzGleiter,String leben,String tot,String dateiname, String ausgabeArt) throws SQLException{
  216.  
  217.         Statement stmnt = null;
  218.         String querry = "SELECT ZelleX, ZelleY, ZelleZustand FROM Gleiter";
  219.  
  220.         int anzGleiterERST=0;
  221.         int zelleX=0;
  222.         int zelleY=0;
  223.         boolean zelleZustand=false;
  224.         boolean figurFertig=false;
  225.  
  226.         try {
  227.             stmnt = connection.createStatement();
  228.             ResultSet rs = stmnt.executeQuery(querry);
  229.             for (int i=0;i<anzGleiter;i++){//anzGleiterERST<=anzGleiter+1) {
  230.                 while (rs.next()) {
  231.                     zelleX = rs.getInt(1);
  232.                     zelleY = rs.getInt(2);
  233.                     int zelleZustandTEMP = rs.getInt(3);
  234.  
  235.                     if (zelleZustandTEMP == 0) {
  236.                         zelleZustand = false;
  237.                     }
  238.                     if (zelleZustandTEMP == 1) {
  239.                         zelleZustand = true;
  240.                     }
  241.  
  242.                     //System.out.println(zelleX + "-" + zelleY + "-" + zelleZustand + "----" + anzGleiterERST);
  243.  
  244.                     try {
  245.                         System.out.println(zelleX+"+"+zelleY+"+"+feldGroesseX+"+"+feldGroesseY);
  246.                         ausgabeSpielstartMYSQL(zelleX, zelleY, zelleZustand, anzGleiterERST, figurFertig, leben, tot, ausgabeArt, dateiname);
  247.                     }
  248.                     catch (IOException e){
  249.  
  250.                     }
  251.  
  252.                 }
  253.                 anzGleiterERST++;
  254.                 rs.beforeFirst();
  255.                 if (anzGleiterERST==(anzGleiter)){
  256.                     figurFertig=true;
  257.                 }
  258.             }
  259.         }
  260.  
  261.         catch (SQLException e){}
  262.     }
  263.  
  264.     public void herschelTable(Connection connection,int anzGleiter,String leben,String tot,String dateiname,String ausgabeArt) throws SQLException{
  265.  
  266.         Statement stmnt = null;
  267.         String querry = "SELECT ZelleX, ZelleY, ZelleZustand FROM Herschel";
  268.  
  269.         int anzHerschelERST=0;
  270.         int zelleX=0;
  271.         int zelleY=0;
  272.         boolean zelleZustand=false;
  273.         boolean figurFertig=false;
  274.  
  275.         try {
  276.             stmnt = connection.createStatement();
  277.             ResultSet rs = stmnt.executeQuery(querry);
  278.             for (int i=0;i<anzGleiter;i++){
  279.                 while (rs.next()) {
  280.                     zelleX = rs.getInt(1);
  281.                     zelleY = rs.getInt(2);
  282.                     int zelleZustandTEMP = rs.getInt(3);
  283.  
  284.                     if (zelleZustandTEMP == 0) {
  285.                         zelleZustand = false;
  286.                     }
  287.                     if (zelleZustandTEMP == 1) {
  288.                         zelleZustand = true;
  289.                     }
  290.  
  291.                     try {
  292.                         ausgabeSpielstartMYSQL(zelleX, zelleY, zelleZustand, anzHerschelERST, figurFertig, leben, tot, ausgabeArt, dateiname);
  293.                     }
  294.  
  295.                     catch (IOException e){
  296.  
  297.                     }
  298.                 }
  299.                 anzHerschelERST++;
  300.                 rs.beforeFirst();
  301.                 if (anzHerschelERST==(anzGleiter)){
  302.                     figurFertig=true;
  303.                 }
  304.             }
  305.         }
  306.  
  307.         catch (SQLException e){}
  308.     }
  309.  
  310.  
  311.     public void ausgabeSpielstartMYSQL(int zelleX, int zelleY, boolean zelleZustand,int anzFigurERST,boolean figurFertig, String leben,String tot,String ausgabeArt, String dateiname) throws IOException{
  312.  
  313.         boolean figurAbfrage=false;
  314.  
  315.         if (figurFertig==true){
  316.             figurAbfrage=true;
  317.         }
  318.  
  319.         if (figurAbfrage==false){
  320.             //if (zelleY+(anzFigurERST*6)>=feldGroesseY || zelleX+(anzFigurERST*6)>=feldGroesseX){
  321.             //    figurAbfrage=true;
  322.             //    System.out.println(feldGroesseY+"hallo123");
  323.             //}
  324.  
  325.             //else {
  326.                 System.out.println(feldGroesseY+"+"+feldGroesseX+"anzfig="+anzFigurERST*6+"//"+zelleY+zelleX);
  327.             //zellen[zelleY + (anzFigurERST * 6)][zelleX + (anzFigurERST * 6)] = zelleZustand;
  328.             zellen[zelleY][zelleX]=zelleZustand;
  329.             //}
  330.         }
  331.  
  332.         if (figurAbfrage==true){
  333.  
  334.             if (ausgabeArt.equals("1")) {
  335.                 System.out.println("test"+feldGroesseX+"start");
  336.                 System.out.println("Generation: " + generation);
  337.                 for (int i = 0; i < feldGroesseY; i++) {
  338.                     for (int j = 0; j < feldGroesseX; j++) {
  339.                         if (zellen[i][j] == true) {
  340.                             System.out.print(leben);
  341.                         } else {
  342.                             System.out.print(tot);
  343.                         }
  344.                     }
  345.                     System.out.println();
  346.                 }
  347.                 generation++;
  348.  
  349.             }
  350.  
  351.             else {
  352.  
  353.                 String filename = "/Users/activeagent/Desktop/Test/"+dateiname;                                                 //Variabler Dateiname(Einträge werden an alte Datei angehängt wenn eine Datei mit dem selben Namen bereits existiert)
  354.                 File file = new File(filename);
  355.                 file.getParentFile().mkdirs();                                                                                  //Erstellt Ordnerstruktur falls nicht vorhanden
  356.                 Writer out;
  357.                 out = new BufferedWriter(new FileWriter(filename,true));
  358.                 try {
  359.  
  360.                     out.append("Generation: " + generation);                                                                    //Ausgabe in welcher Generation das Spiel sich momentan befindet
  361.                     out.append("\n");                                                                                           //"\n" für Zeilenumbruch
  362.                     for (int i = 0; i < feldGroesseY; i++) {                                                                    //Geschachtelte for-Schleife um jedes Feld im Array durchzugehen
  363.                         for (int j = 0; j < feldGroesseX; j++) {
  364.                             if (zellen[i][j] == true) {
  365.                                 out.append(leben);                                                                              //lebende Zellen
  366.                             } else {
  367.                                 out.append(tot);                                                                                //gestorbene Zellen
  368.                             }
  369.                         }
  370.                         out.append("\n");                                                                                       //Zeilenumbruch nach einer Zeile des Spielfeldes
  371.                     }
  372.                     out.close();
  373.  
  374.                     generation=1;                                                                                               //nächste Generation
  375.  
  376.                 }
  377.  
  378.                 catch (IOException e){
  379.  
  380.                 }
  381.  
  382.             }
  383.         }
  384.  
  385.     }
  386.  
  387.  
  388.  
  389.  
  390. }
  391.  
  392.  
  393.  
  394. public class GameOfLife {
  395.  
  396.     public static void main(String[] args) throws Exception{
  397.         //String driverName="org.gjt.mm.mysql.Driver";
  398.         //class.forName(driverName).newInstance;
  399.  
  400.         System.out.println("Loading driver...");
  401.  
  402.         try {
  403.             Class.forName("com.mysql.jdbc.Driver");
  404.             System.out.println("Driver loaded!");
  405.         } catch (ClassNotFoundException e) {
  406.             throw new IllegalStateException("Cannot find the driver in the classpath!", e);
  407.         }
  408.  
  409.         String serverName="localhost:3306";
  410.         String myDatabase="Startpattern";
  411.         String url = "jdbc:mysql://"+serverName+"/"+myDatabase;
  412.  
  413.         String username="root";
  414.         String password="joshua123";
  415.  
  416.  
  417.  
  418.  
  419.  
  420.         String dateiname="temp";
  421.         Scanner scanner = new Scanner(System.in);
  422.         System.out.println("Bitte geben Sie die Regeln an: ");
  423.  
  424.         Zellen objekt = new Zellen();                                                                                   //Objekterzeugung
  425.  
  426.         int defaultGr=50;
  427.         boolean defGr=true;
  428.  
  429.         System.out.println("Wählen Sie das Startfeld(1 Gleiter/2 Herschel/3 Zufall)");
  430.         int preset= scanner.nextInt();
  431.         int anzPreset=0;
  432.         if (preset== 1 || preset==2){
  433.             if (preset==1){
  434.                 System.out.println("Geben Sie die Anzahl der Gleiter an: ");
  435.                 anzPreset= scanner.nextInt();
  436.             }
  437.             else {
  438.                 System.out.println("Geben Sie die Anzahl der Herschel an: ");
  439.                 anzPreset= scanner.nextInt();
  440.             }
  441.  
  442.  
  443.             if (anzPreset*6>defaultGr){
  444.                 defGr=false;
  445.                 System.out.println("hallo??");
  446.                 objekt.spielFeld(anzPreset,defGr);
  447.                 System.out.println("wtf");
  448.             }
  449.  
  450.             else {
  451.                 objekt.spielFeld(defaultGr,defGr);
  452.             }
  453.  
  454.         }
  455.  
  456.         if (preset==3) {
  457.             //objekt.spielFeld(defaultGr,defGr);
  458.             objekt.arrayStartwerte();                                                                                       //Methode arrayStartawrte aufrufen
  459.         }
  460.  
  461.         objekt.regelnSetzen();
  462.         int anzahlGenerationen=50;                                                                                      //Anzahl der Generationen (Spielzüge) setzen
  463.  
  464.         System.out.println("Geben Sie die Art der Darstellung an");
  465.         System.out.print("lebendig: ");
  466.         String leben= scanner.next();
  467.         System.out.print("tot: ");
  468.         String tot=scanner.next();
  469.  
  470.         System.out.println("Geben Sie die Art der Ausgabe an (1 Konsole/2 Textdatei):");
  471.         String ausgabeArt = scanner.next();
  472.  
  473.         if (ausgabeArt.equals("2")){
  474.             System.out.println("Geben Sie den gewünschten Namen der Datei an: ");
  475.             dateiname= scanner.next();
  476.         }
  477.  
  478.         objekt.regelnSetzen();
  479.  
  480.  
  481.         try (Connection connection = DriverManager.getConnection(url, username, password)){
  482.             System.out.println("Zu mysql verbunden");
  483.  
  484.             if (preset==1) {
  485.                 objekt.gleiterTable(connection,anzPreset,leben,tot,dateiname,ausgabeArt);
  486.             }
  487.             if (preset==2) {
  488.                 objekt.herschelTable(connection,anzPreset,leben,tot,dateiname,ausgabeArt);
  489.             }
  490.         }
  491.         catch (SQLException e){
  492.             throw new IllegalStateException("konnte nicht verbinden");
  493.         }
  494.  
  495.  
  496.  
  497.         if (ausgabeArt.equals("1")) {                                                                                   //Wenn in ausgabeArt "1" steht
  498.             objekt.ausgabeSpielKonsole(leben, tot);                                                                     //Methode ausgabeSpielKonsole aufrufen um Startfeld auszugeben mit übergabe der Strings leben und tot
  499.         }
  500.  
  501.         if (ausgabeArt.equals("2")) {
  502.  
  503.             try {
  504.                 objekt.ausgabeSpielTXT(leben,tot,dateiname);                                                            //   "     ausgabeSpielTXT                       "                                      leben, tot und dateiname
  505.             }
  506.             catch (IOException e){
  507.             }
  508.         }
  509.  
  510.         for (int i=0;i<anzahlGenerationen;i++){                                                                         //for-Schleife mit anzahlGenerationen als Anzahl der Durchläufe
  511.             objekt.spielZug();                                                                                          //Bei jedem durchgang die Methode spielZug aufrufen um eine Generation zu simulieren
  512.             if (ausgabeArt.equals("1")) {
  513.                 objekt.ausgabeSpielKonsole(leben, tot);                                                                 //und ausgabeSpielKonsole um jede Generation auszugeben
  514.  
  515.                 try {
  516.                     Thread.sleep(500);                                                                                  //nach jeder Ausgabe 1/2 Sekunde warten
  517.                 }
  518.                 catch (InterruptedException e){
  519.  
  520.                 }
  521.             }
  522.  
  523.             if (ausgabeArt.equals("2")) {
  524.                 try {
  525.                     objekt.ausgabeSpielTXT(leben,tot,dateiname);
  526.                 }
  527.                 catch (IOException e){
  528.                 }
  529.             }
  530.         }
  531.      }
  532. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement