Spiel des Lebens (Game of Life)

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • Spiel des Lebens (Game of Life)

    Das hier ist nur eine Hilfe... Wer einfach nur diesen perfekten Code den ich mit eigen erbrachter Denkleistung verfasst habe kopiert... kackt sich selbst am bein... Es dient nur zur Hilfe, falls ihr kleine Fraqumente nicht selber Lösen könnt weil euer Intellekt das nicht zulässt. Also einfach mal die Ziege bei den Eiern packen und selber EASY CODEN....
    ciao


    Quellcode

    1. import java.io.File;
    2. import java.io.FileNotFoundException;
    3. import java.util.Formatter;
    4. import java.util.Scanner;
    6. /**
    7. *
    8. */
    10. /**
    11. * @author Marcel Hentschel
    12. * @licence Marcel Hentschel
    13. * @copy Dont copy that Floppy
    14. */
    15. public class SpielDesLebens {
    17. static void allZero(int [][] Feld){
    18. for (int i = 0; i < Feld.length; i++){
    19. for (int j = 0; j < Feld[0].length; j++){
    20. Feld[i][j] = 0;
    21. }
    22. }
    23. }
    25. static void ausgabe(int [][] Feld, int generation){
    26. System.out.printf("Generation:" + generation +"\n");
    27. for (int i = 0; i < Feld.length; i++){
    28. for (int j = 0; j < Feld[0].length; j++){
    29. System.out.printf(Feld[i][j]+" ");
    30. }
    31. System.out.println();
    32. }
    33. }
    34. static int freundeZaehlen(int [][] Feld, int x, int y){
    35. int count = 0;
    36. //x=Feld.length;
    37. //y=Feld[0].length;
    38. if (x+1 >= Feld.length){
    40. if (y-1 < 0)count= count + Feld[x-Feld.length+1][y+Feld.length-1];
    41. else count= count + Feld[x-Feld.length+1][y-1];
    43. if (y+1 >= Feld[0].length) count= count + Feld[x-Feld.length+1][y-Feld.length+1];
    44. else count= count + Feld[x-Feld.length+1][y+1];
    46. count= count + Feld[x-Feld.length+1][y];
    48. }
    49. else{
    51. if (y-1 < 0) count= count + Feld[x+1][y+Feld.length-1];
    52. else count= count + Feld[x+1][y-1];
    54. if (y+1 >= Feld[0].length) count= count + Feld[x+1][y-Feld.length+1];
    55. else count= count + Feld[x+1][y+1];
    57. count= count + Feld[x+1][y];
    59. }
    60. if (x-1 < 0){
    62. if (y-1 < 0) count= count + Feld[x+Feld.length-1][y+Feld.length-1];
    63. else count= count + Feld[x+Feld.length-1][y-1];
    65. if (y+1 >= Feld[0].length) count= count + Feld[x+Feld.length-1][y-Feld.length+1];
    66. else count= count + Feld[x+Feld.length-1][y+1];
    68. count= count + Feld[x+Feld.length-1][y];
    70. }
    71. else{
    73. if (y+1 >= Feld[0].length) count= count + Feld[x-1][y-Feld.length+1];
    74. else count= count + Feld[x-1][y+1];
    76. if (y-1 < 0) count= count + Feld[x-1][y+Feld.length-1];
    77. else count= count + Feld[x-1][y-1];
    79. count= count + Feld[x-1][y];
    81. }
    83. if (y+1 >= Feld[0].length) count= count + Feld[x][y-Feld.length+1];
    84. else count= count + Feld[x][y+1];
    86. if (y-1 < 0) count= count + Feld[x][y+Feld.length-1];
    87. else count= count + Feld[x][y-1];
    89. return count;
    90. }
    92. static int deadOrAlive (int [][] Feld, int x, int y){
    93. int count = freundeZaehlen(Feld, x, y);
    94. if (count == 3)
    95. return 1;
    96. else
    97. return 0;
    98. }
    99. static int aliveOrDead (int [][] Feld, int x, int y){
    100. int count = freundeZaehlen(Feld, x, y);
    101. if (count == 3 || count == 2)
    102. return 1;
    103. else
    104. return 0;
    105. }
    107. static int[][] myGeneration(int [][] Feld, int zeit, int max){
    108. if (zeit == 0) return Feld;
    110. int [][] newFeld = new int [Feld.length][Feld[0].length];
    112. for (int i = 0; i < Feld.length; i++){
    113. for (int j = 0; j < Feld[0].length; j++){
    114. if (Feld[i][j] == 0)
    115. newFeld[i][j] = deadOrAlive(Feld, i, j);
    116. else
    117. newFeld[i][j] = aliveOrDead(Feld, i, j);
    118. }
    119. }
    120. if (zeit>1)
    121. ausgabe(newFeld, max-zeit);
    122. return myGeneration(newFeld, zeit-1, max);
    123. }
    125. static int[][] dateiEinlesen(String filename){
    126. int [][] Feld = new int[0][0];
    127. try {
    128. File file = new File(filename);
    129. Scanner sc = new Scanner(file);
    131. String Zeile = sc.next();
    132. int xsize = Integer.parseInt(Zeile);
    133. Zeile = sc.next();
    134. int ysize = Integer.parseInt(Zeile);
    136. char [] a = new char [ysize];
    138. Feld = new int [xsize][ysize];
    140. for (int i = 0; i < Feld.length; i++){
    141. Zeile = sc.next();
    142. a = Zeile.toCharArray();
    143. for (int j = 0; j < Feld[0].length; j++){
    144. Feld[i][j] = a[j] - 48;
    146. }
    147. }
    149. sc.close();
    151. }
    152. // Falls die Datei nicht gefunden wurde, gibt er eine Fehlermeldung aus
    153. catch (FileNotFoundException e) {
    154. System.err.println("Benutzung:" +
    155. "\n [Programmname] schreibt die Zahlen" +
    156. "\n aus der Quelldatei (\"zahlen.dat\") in die Zieldatei (\"zahlen_new.dat\") und sortiert sie aufsteigend." +
    157. "\n [Programmname] [-auf/-ab] schreibt die Zahlen" +
    158. "\n Je nach dem Parameter -auf oder -ab auf-oder absteigend in die Zieldatei.");
    159. System.exit(1);
    160. }
    161. return Feld;
    162. }
    165. /**
    166. * @param args
    167. */
    168. public static void main(String[] args) {
    170. ausgabe(myGeneration(dateiEinlesen(args[0] + ".dat"), Integer.parseInt(args[1]), Integer.parseInt(args[1])), Integer.parseInt(args[1])-1);
    171. }
    173. }
    Alles anzeigen
    WTF?

  • Conways Spiel des Lebens

    Conways Spiel des Lebens ist ein von dem Mathematiker John Horton Conway 1970 entworfenes System zweidimensional angeordneter zellulärer Automaten. Es ist eine einfache und bis heute populäre Umsetzung der Automaten-Theorie von Stanisław Marcin Ulam.

    Die Regeln:
    Die Folgegeneration wird für alle Zellen gleichzeitig berechnet und ersetzt die aktuelle Generation. Der Zustand einer Zelle, lebendig oder tot in der Folgegeneration hängt nur vom Zustand der acht Nachbarzellen dieser Zelle in der aktuellen Generation ab.

    Die von Conway zu Anfang verwendeten Regeln sind:
    * Eine Zelle mit genau drei lebenden Nachbarn wird in der Folgegeneration neu geboren.
    * Lebende Zellen mit weniger als zwei lebenden Nachbarn sterben in der Folgegeneration an Einsamkeit.
    * Lebende Zellen mit mehr als drei lebenden Nachbarn sterben in der Folgegeneration an Überbevölkerung

    Mit diesen drei einfachen Regeln entsteht aus bestimmten Anfangsmustern im Laufe des Spiels eine Vielfalt komplexer Strukturen. Einige bleiben unverändert, andere oszillieren und wieder andere wachsen oder vergehen. Manche Strukturen, sogenannte Gleiter, bewegen sich auf dem Spielfeld fort.

  • Hi, freut mich, dass du dich hierher verirrst hast.

    Schöner Code, auch wenn unser Prof das JavaDoc vermissen wird..
    Aber funktioniert das Programm bei dir?

    Habe die blinker.dat wie beschrieben erstellt (siehe Anhang) und dein Programm mit den Argumenten "blinker 2" aufgerufen

    als ergebnis erhalte ich nur eine arrayOutOfBoundException
    in dieser schleife

    Quellcode

    1. for (int j = 0; j < Feld[0].length; j++){
    2. Feld[i][j] = a[j] - 48;
    4. }

  • ich habe mich hier nicht verirrt....
    ich studiere doch mit dir...

    javadoc comments sind noch nicht drin weil wenns dann jemand kopiert muss er sich wenigstens noch etwas gedanken machen....
    vielleicht hast du die datei nicht richtig gespeichert...
    So muss die datei blinker.dat aussehen
    -----------------------------------------------------------------
    4 5
    00100
    00100
    00100
    00000
    -----------------------------------------------------------------
    ich hab mir die arbeit gemacht noch ein paar andere schöne sachen aufzuschreiben in ne datei....
    -----------------------------------------------------------------
    12 30
    000000000000000000000000000000
    001000000000000000000000000000
    001000000000000000000000000000
    001000000000000000000000000000
    000000000000000110000000000000
    000000000000000100000000000000
    000000000000000000100000000000
    000000000000000001100000000000
    000000000000000000000000000000
    000000000000000000000000000000
    000000000000000000000000000000
    000000000000000000000000000000
    -----------------------------------------------------------------
    try again...
    ciao
    Dateien

    • blinker.dat

      (31 Byte, 805 mal heruntergeladen, zuletzt: )
    WTF?

  • Meine Version

    Das ist meine Version :)

    Quellcode

    1. import java.io.File;
    2. import java.io.FileNotFoundException;
    3. import java.util.*;
    4. public class Aufgabe4 {
    5. public static boolean [][] makeArray( String dateiName, File myFile )
    6. throws FileNotFoundException{
    7. int zeile, spalte;
    8. Scanner input = new Scanner( myFile );
    9. spalte = input.nextInt();
    10. zeile = input.nextInt();
    11. boolean gameOfLife [][] = new boolean[spalte][zeile];
    12. for( int x = 0; x < spalte; x += 1)
    13. for( int y = 0; y < zeile; y += 1 ){
    14. if( input.nextInt() == 1)
    15. gameOfLife[x][y] = true;
    16. else
    17. gameOfLife[x][y] = false;
    18. }
    19. return gameOfLife;
    20. }
    21. public static void printCell( boolean [][] cell, int gen ){
    22. System.out.printf("Generation: %d\n", gen);
    23. for( int i = 0; i < cell.length; i += 1){
    24. for( int x = 0; x < cell[i].length; x += 1){
    25. if ( cell[i][x] ){
    26. System.out.printf("1 ");
    27. }
    28. else{
    29. System.out.printf("0 ");
    30. }
    31. }
    32. System.out.printf("\n");
    33. }
    34. }
    35. public static boolean zelleAmLeben(int x, int y, boolean [][] cell){
    36. boolean amLeben = false;
    37. if ( ( x >= 0 ) && ( x < cell.length ) && (y >= 0) && (y < cell[0].length ) ){
    38. amLeben = cell[x][y];
    39. return amLeben;
    40. }
    41. else if( ( x < 0 ) && ( y >= 0 ) && ( y < cell[0].length ) ){
    42. amLeben = cell[cell.length-1][y];
    43. return amLeben;
    44. }
    45. else if( ( x < cell.length ) && ( y >= 0 ) && ( y < cell[0].length ) ){
    46. amLeben = cell[0][y];
    47. return amLeben;
    48. }
    49. else if( ( y < 0 ) && ( x >= 0 ) && (x < cell.length ) ){
    50. amLeben = cell[x][cell[0].length-1];
    51. return amLeben;
    52. }
    53. else if( ( y <= cell[0].length ) && ( x >= 0 ) && ( x < cell.length ) ){
    54. amLeben = cell[x][0];
    55. return amLeben;
    56. }
    57. else if( ( x < 0 ) && ( y < 0 ) ){
    58. amLeben = cell[cell.length-1][cell[0].length-1];
    59. return amLeben;
    60. }
    61. else if( ( x > cell.length ) && ( y > cell[0].length ) ){
    62. amLeben = cell[0][0];
    63. return amLeben;
    64. }
    65. else {
    66. amLeben = false;
    67. return amLeben;
    68. }
    69. }
    70. public static int anzahlNachbarn( int x, int y, boolean [][] cell ){
    71. int count = 0;
    72. if ( zelleAmLeben( x-1, y-1, cell ) )
    73. count += 1;
    74. if ( zelleAmLeben( x-1, y, cell ) )
    75. count += 1;
    76. if ( zelleAmLeben( x-1, y+1, cell ) )
    77. count += 1;
    78. if ( zelleAmLeben( x, y-1, cell ) )
    79. count += 1;
    80. if ( zelleAmLeben( x, y+1, cell ) )
    81. count += 1;
    82. if ( zelleAmLeben( x+1, y-1, cell ) )
    83. count += 1;
    84. if ( zelleAmLeben( x+1, y, cell ) )
    85. count += 1;
    86. if ( zelleAmLeben( x+1, y+1, cell ) )
    87. count += 1;
    88. return count;
    89. }
    90. public static boolean [][] nextGen ( boolean [][] cell){
    91. boolean [][] tempCell = new boolean [cell.length][cell[0].length];
    92. for( int x = 0; x < cell.length; x += 1){
    93. for( int y = 0; y < cell[x].length; y += 1){
    94. boolean alive_now = cell[x][y], alive_then = false;
    95. int anzahl_nachbarn = anzahlNachbarn( x, y, cell );
    96. if (( alive_now ) && ( anzahl_nachbarn < 2 )){
    97. alive_then = false;
    98. }
    99. else if (( alive_now ) && ( anzahl_nachbarn > 3 )){
    100. alive_then = false;
    101. }
    102. else if (( !alive_now ) && ( anzahl_nachbarn == 3 )){
    103. alive_then = true;
    104. }
    105. else if (( alive_now ) && (( anzahl_nachbarn == 2 ) || ( anzahl_nachbarn == 3 ))){
    106. alive_then = true;
    107. }
    108. tempCell[x][y] = alive_then;
    109. }
    110. }
    111. for( int x = 0; x < cell.length; x += 1)
    112. for( int y = 0; y < cell[x].length; y += 1){
    113. cell[x][y] = tempCell[x][y];
    114. }
    115. return cell;
    116. }
    117. public static void spielDesLebens( String [] parameter ){
    118. String dateiName = parameter[0];
    119. int anzahlGen = Integer.parseInt( parameter[1] );
    120. File myFile = new File( dateiName+".dat" );
    121. try {
    122. boolean [][] cell = makeArray( dateiName, myFile );
    123. int gen = 1;
    124. while( anzahlGen > 0){
    125. cell = nextGen( cell );
    126. printCell( cell, gen );
    127. anzahlGen -= 1;
    128. gen += 1;
    129. }
    130. } catch (FileNotFoundException e) {
    131. System.out.printf("Fehler bei der Array Erstellung!!");
    132. }
    133. }
    134. public static void main(String[] args) {
    135. switch( args.length){
    136. case 2:
    137. spielDesLebens( args );
    138. break;
    139. default:
    140. System.out.printf("usage: Dateiname | anzahlGen ");
    141. }
    142. }
    143. }
    Alles anzeigen

  • und hier noch meine Lösung.. knapp 100 Zeilen..

    Quellcode

    1. import java.io.File;
    2. import java.io.IOException;
    3. import java.util.Scanner;
    4. /**
    5. *
    6. * @author Torben Brodt
    7. * @version 1.0
    8. *
    9. * <p />Game of Life (John Cornway)
    10. */
    11. public class A4_Game_of_Life {
    13. /**
    14. * @param args
    15. */
    16. public static void main(String[] args) throws IOException {
    17. // TODO Auto-generated method stub
    19. String source = "blinker.dat";
    20. int dimensionen = 5;
    22. try {
    23. source = args[0];
    24. dimensionen = Integer.parseInt(args[1]);
    25. } catch(Exception e) {
    26. System.err.println("Keine Werte übergeben -> Standardwerte werden genutzt!");
    27. }
    29. Scanner sc = new Scanner(new File(source));
    30. int rows = sc.nextInt();
    31. int columns = sc.nextInt();
    32. boolean[][] cell = new boolean[rows][columns];
    34. for(int x = 0; x < rows; x++) {
    35. int y=0;
    36. for(char digit : sc.next().toCharArray()) {
    37. if(digit == '1')
    38. cell[x][y] = true;
    39. else
    40. cell[x][y] = false;
    41. y++;
    42. }
    43. }
    45. System.out.println("Generation 0");
    46. show(cell);
    48. for(int i=1; i<dimensionen; i++) {
    49. System.out.println("Generation "+i);
    50. cell = nextGen(cell);
    51. }
    52. }
    54. /**
    55. * Ausgabefunktion
    56. * @param cell
    57. */
    58. static void show(boolean [][] cell) {
    59. for(boolean[] arrZeile : cell) {
    60. for(boolean arrSpalte : arrZeile) {
    61. int ausgabe = arrSpalte == true ? 1 : 0;
    62. System.out.print(ausgabe);
    63. }
    64. System.out.println();
    65. }
    66. System.out.println();
    67. }
    69. /**
    70. * Lebt die Zelle?
    71. * @param column -> Spalte
    72. * @param row -> Zeile
    73. * @param cell -> Array
    74. * @return -> true / false
    75. */
    76. static boolean cellAlive(int column, int row, boolean [][] cell){
    77. int right = (column+1 > cell[0].length-1) ? 0 : column+1;
    78. int left = (column-1 < 0) ? cell[0].length-1 : column-1;
    79. int bottom = (row+1 > cell.length-1) ? 0 : row+1;
    80. int top = (row-1 < 0) ? cell.length-1 : row-1;
    82. int treffer=0;
    83. //die 8 Nachbarn im Uhrzeigersinn
    84. treffer += cell[top][column] ? 1 : 0;
    85. treffer += cell[top][right] ? 1 : 0;
    86. treffer += cell[row][right] ? 1 : 0;
    87. treffer += cell[bottom][right] ? 1 : 0;
    88. treffer += cell[bottom][column] ? 1 : 0;
    89. treffer += cell[bottom][left] ? 1 : 0;
    90. treffer += cell[row][left] ? 1 : 0;
    91. treffer += cell[top][left] ? 1 : 0;
    93. if(cell[row][column] == true && (treffer == 2 || treffer == 3)) //lebende Zelle bleibt lebendig
    94. return true;
    95. else if(cell[row][column] == false && (treffer == 3)) //tote Zelle wird lebendig
    96. return true;
    97. else
    98. return false;
    99. }
    101. /**
    102. * Schickt alle Array Elemente durch den cellAlive Check
    103. * @param cell -> die alte Generation
    104. * @return -> das temporäre Array (die neue Generation)
    105. */
    106. static boolean [][] nextGen ( boolean[][] cell) {
    107. boolean [][] tmp = new boolean [cell.length][cell[0].length];
    108. for(int y=0; y<cell.length; y++)
    109. for(int x=0; x<cell[0].length; x++)
    110. tmp[y][x] = cellAlive(x, y, cell);
    112. show(tmp);
    113. return tmp;
    114. }
    115. }
    Alles anzeigen

  • Jo, servus... hier meins...

    Quellcode

    1. import java.io.File;
    2. import java.io.FileNotFoundException;
    3. import java.util.*;
    5. /**
    6. * <p>
    7. * <b>Organisation:</b> FH-Wiesbaden<br>
    8. * <b>Homepage:</b> <a href="http://www.fh-wiesbaden.de">www.fh-wiesbaden.de</a><br>
    9. * <b>Fachbereich:</b> 06 - Meieninformatik<br>
    10. * </p>
    11. * <p>
    12. * <b>Entwickler:</b> Berntheisel, Stefan<br>
    13. * <p>
    14. * <b>Programm:</b><i> Game of Life </i><br>
    15. * </p>
    16. *
    17. * @author sbern001 (Username)
    18. * @version 1.0
    19. * @docRoot .
    20. */
    22. public class U11A04 {
    24. /**
    25. * Haupprogramm
    26. * @param args Kommandozeilenparameter
    27. * arg[0] = Zellen-Datei
    28. * arg[1] = Generationen
    29. */
    31. public static void main (String args[])
    32. {
    33. String filename = "";
    34. int generation = 0;
    36. try
    37. {
    38. filename = args[0];
    39. generation = Integer.parseInt(args[1]);
    40. if(generation < 1) {
    41. System.err.printf("Keine negative Anzahl an Generaionen moeglich!\n");
    42. System.exit(-1);
    43. }
    44. }
    45. catch (Exception e)
    46. {
    47. System.out.printf("Bitte ueberpruefen Sie die Kommandozeilenparameter!\n\n");
    48. System.out.printf(" <Programm> [Dateiname] [Anzahl_Gernerationen]\n");
    49. System.exit(-1);
    50. }
    52. int integer_cell[][] = readCellFile(filename);
    54. if(integer_cell.length == 0)
    55. {
    56. System.err.printf("Die Datei \"%s\" kann nicht gelesen werden!\n",filename);
    57. System.exit(-1);
    58. }
    60. boolean cell[][] = intToBool(integer_cell);
    62. System.out.printf("Generation: 0\n");
    63. drawCell(cell);
    65. for(int i = 0; i < generation; i++)
    66. cell = nextGen(cell);
    68. System.out.printf("Generation: %d\n",generation);
    69. drawCell(cell);
    71. }
    73. /**
    74. * Methode: nextGen
    75. * @param cell Ausgangs-Generation der Zellen
    76. * @return Nexte Generatiation der Zellen
    77. */
    79. static boolean[][] nextGen(boolean cell[][])
    80. {
    81. cell = expansionCell(cell);
    83. boolean life[][] = new boolean[cell.length][cell[0].length];
    85. for(int x = 1; x < cell.length - 1; x++)
    86. for(int y = 1; y < cell[0].length - 1; y++)
    87. {
    88. if(cell[x][y] && life(cell, x, y, 2) || life(cell, x, y, 3)) life[x][y] = true;
    89. else if(!cell[x][y] && life(cell, x, y, 3)) life[x][y] = true;
    90. else life[x][y] = false;
    91. }
    93. return reduceCell(life);
    94. }
    96. /**
    97. * Methode: expansionCell
    98. * @param cell Ausgangs-Zellenmatrix
    99. * @return Alle Seiten und Ecken der Ausgangs-Zellenmatrix wurden
    100. * an den gegenueberliegenden Punkten angehaengt (erweitert)
    101. */
    103. static boolean[][] expansionCell (boolean cell[][])
    104. {
    105. boolean expansion[][] = new boolean[cell.length + 2][cell[0].length + 2];
    107. int cx = cell.length - 1;
    108. int cy = cell[0].length - 1;
    109. int ex = expansion.length - 1;
    110. int ey = expansion[0].length - 1;
    112. // Kopieren von "cell" in die mitte von "expansion"
    113. for(int x = 0; x <= cx; x++)
    114. for(int y = 0; y <= cy; y++)
    115. expansion[x+1][y+1] = cell[x][y];
    117. // Ecken verspiegelt kopieren
    118. expansion[0 ][0 ] = cell[cx][cy];
    119. expansion[ex][ey] = cell[0 ][0 ];
    120. expansion[0 ][ey] = cell[cx][0 ];
    121. expansion[ex][0 ] = cell[0 ][cy];
    123. // Obere- und Untere Seite verspiegelt kopieren
    124. for(int x = 0; x <= cx; x++) {
    125. expansion[x+1][0] = cell[x][cy];
    126. expansion[x+1][ey] = cell[x][0]; }
    128. // Linke- und Rechte Seite verspiegelt kopieren
    129. for(int y = 0; y <= cy; y++) {
    130. expansion[0][y+1] = cell[cx][y];
    131. expansion[ex][y+1] = cell[0][y]; }
    133. return expansion;
    134. }
    136. /**
    137. * Methode: reduceCell
    138. * @param cell Erweiterte Zellenmatrix
    139. * @return Zuruecksetzen in die Ursprungs-Zellenmatrix
    140. */
    142. static boolean[][] reduceCell (boolean cell[][])
    143. {
    144. boolean reduce[][] = new boolean[cell.length - 2][cell[0].length - 2];
    146. int rx = reduce.length - 1;
    147. int ry = reduce[0].length - 1;
    149. // Verkleinern von "cell" durch kopieren nach "reduce"
    150. for(int x = 0; x <= rx; x++)
    151. for(int y = 0; y <= ry; y++)
    152. reduce[x][y] = cell[x+1][y+1];
    154. return reduce;
    155. }
    157. /**
    158. * Methode: life
    159. * @param cell Zellenmatrix
    160. * @param x X-Koordinate in der Matrix
    161. * @param y Y-Koordinate in der Matrix
    162. * @param life_value Anzahl der zusuchenden lebenden Zellen
    163. * @return
    164. */
    166. static boolean life(boolean cell[][], int x, int y, int life_value)
    167. {
    168. int count = 0;
    170. // Prueft die umliegenden Zellen auf Leben
    171. // Läuft im Uhrzeiger, start bei 3 Uhr
    172. if(cell[x][y+1]) count++;
    173. if(cell[x+1][y+1]) count++;
    174. if(cell[x+1][y]) count++;
    175. if(cell[x+1][y-1]) count++;
    176. if(cell[x][y-1]) count++;
    177. if(cell[x-1][y-1]) count++;
    178. if(cell[x-1][y]) count++;
    179. if(cell[x-1][y+1]) count++;
    181. if(count >= life_value) return true;
    182. else return false;
    183. }
    185. /**
    186. * Methode: readCellFile
    187. * @param filename Dateiname der Zellenmatrix
    188. * @return Zellenmatrix
    189. */
    191. static int[][] readCellFile(String filename)
    192. {
    193. int x,y;
    194. int null_cell[][] = new int[0][0];
    196. try
    197. {
    199. File file = new File(filename);
    200. if(!file.exists() || !file.canRead()) return null_cell;
    202. Scanner sc = new Scanner(file);
    204. x = sc.nextInt();
    205. y = sc.nextInt();
    207. if(x < 3 && y < 3) { return null_cell; }
    209. int cell[][] = new int[x][y];
    211. for(int i = 0; i < x; i++)
    212. for(int j = 0; j < y; j++)
    213. cell[i][j] = sc.nextInt();
    215. return cell;
    216. }
    217. catch(FileNotFoundException e)
    218. {
    219. return null_cell;
    220. }
    221. }
    223. /**
    224. * Methode: intToBool
    225. * @param cell Zellenmatrix als Integer
    226. * @return Zellenmatrix als Boolean
    227. */
    229. public static boolean[][] intToBool(int cell[][])
    230. {
    231. boolean bool_cell[][] = new boolean[cell.length][cell[0].length];
    233. for(int i = 0; i < cell.length; i++)
    234. for(int j = 0; j < cell[0].length; j++)
    235. if(cell[i][j] < 1) bool_cell[i][j] = false;
    236. else bool_cell[i][j] = true;
    238. return bool_cell;
    239. }
    241. /**
    242. * Methode: drawCell
    243. * @param cell Zellenmatrix
    244. */
    246. public static void drawCell (boolean cell[][])
    247. {
    248. for(int i = 0; i < cell.length; i++) {
    249. for(int j = 0; j < cell[0].length; j++) {
    250. if(cell[i][j]) System.out.print("1");
    251. else System.out.print("0");
    253. if(j < cell[0].length - 1) System.out.print(" ");
    254. }
    255. System.out.println();
    256. }
    257. }
    258. }
    Alles anzeigen