Avec mon aide s'il vous plaît implémentation Java de base du jeu de Conway de la vie

Question

J'ai passé un bon moment d'essayer d'écrire un programme pour mettre en œuvre le jeu de Conway de la vie - lien avec plus d'info. . Je suivais des guides en ligne et on m'a donné la majorité des fonctions. J'ai écrit les méthodes « suivant » et « voisins » ci-dessous. Quelqu'un pourrait-il me dire si ce sont de bonnes mises en œuvre, et comment ils pourraient être mieux s'il vous plaît?

Le but de l'exercice était de ne pas modifier ou modifier les autres méthodes et il suffit d'écrire la méthode suivante! :)

import java.io.*;
import java.util.Random;

public class Life {

private boolean[][] cells;

public static void main( String[] args ) {
  Life generation = new Life( );
  for (int i = 0; i != 10; i++) {
    System.out.println( generation );
    generation.next( );
  }
}
// Constructors

public void next (){

  int SIZE;
  SIZE=cells.length;
  boolean[][] tempCells = new boolean [SIZE] [SIZE]; 

  for( int i=0; i<SIZE; i++ ) {
 for( int j=0; j<SIZE; j++ ) {
  tempCells[i][j] = cells[i][j];
 }
  } 
  for (int row = 0; row < cells.length ; row++)
  {
    for (int col = 0 ; col < cells[row].length ; col++)
    {
      if ( neighbours(row, col) > 3  ||  neighbours(row, col) < 2 )
      {
        tempCells[row][col] = false;
      }
      else if (neighbours(row, col) == 3 )
      {
        tempCells[row][col] = true;
      }      

    }

  }
  cells = tempCells;

}


public int neighbours (int row, int col) {
  int acc=0;
  for ( int i = row -1; i <= row + 1 ; i++)
    {
     for (int j = col -1 ; j <= col + 1 ; j++)
       {
       try {
         if (cells[i][j]==true && (i != row || j!=col))
         {
           acc++;
         }          
       } catch ( ArrayIndexOutOfBoundsException f)
       {continue;}
     }
  }
  return acc;
}


// Initialises 6 * 6 grid with Glider pattern.
public Life( ) {
final int SIZE = 8;
// Arguably, this should have been a class (static) array.
final int[][] pairs = {{2,4},{3,3},{1,2},{2,2},{3,2}};
cells = new boolean[ SIZE ][ ];
for (int row = 0; row < SIZE; row ++) {
cells[ row ] = new boolean[ SIZE ];
}
for (int pair = 0; pair < pairs.length; pair ++) {
final int row = pairs[ pair ][ 0 ];
final int col = pairs[ pair ][ 1 ];
cells[ row ][ col ] = true;
}
}
 // Initialise size * size grid with random cells.
//public Life( int size ) {
//final Random rand = new Random( );
//cells = new boolean[ size ][ ];
//for (int row = 0; row < size; row ++) {
//cells[ row ] = new boolean[ size ];
//for (int col = 0; col < size; col ++) {
//cells[ row ][ col ] = (rand.nextInt( 2 ) == 0);
//}
//}
//}
// Public methods and helper methods.

@Override
public String toString( ) {
String result = "";
for (int row = 0; row < cells.length; row ++) {
final boolean[] column = cells[ row ];
for (int col = 0; col < column.length; col ++) {
result = result + (column[ col ] ? "x" : ".");
}
result = result + "\n";
}
return result;
}
}

Answer 1

Vous n'avez pas besoin de copier le contenu de cells à tempCells (la première boucle imbriquée dans next). Au lieu de cela, vous pouvez ajouter une clause supplémentaire à la if-else dans la boucle suivante. En outre, mémoriser le résultat de neighbours peut être une bonne idée pour la vitesse et la clarté.

for (int row = 0; row < cells.length ; row++)
    for (int col = 0 ; col < cells[row].length ; col++) {
       int n = neighbours(row,col);

       if (n > 3  ||  n < 2)
           tempCells[row][col] = false;
       else if (n == 3)
           tempCells[row][col] = true;
       else
           tempCells[row][col] = cells[row][col];
    }

(En dehors de cela, semble bien, mais je n'ai pas courir et testé votre code.)

Answer 2

Ne pas utiliser ArrayIndexOutOfBoundException pour calculer hors limites (conditions OOB). Il tue la performance. Mieux utiliser le mécanisme enveloppant pour traiter votre tableau comme une sphère afin que vous ne rencontrez pas OOBs du tout. Vous pouvez essayer quelque chose comme ceci:

public Cell[] getNeighbours(int i, int j) {
int i2 = i - 1, i3 = i + 1, j2 = j - 1, j3 = j + 1;
if (i2 == -1) i2 = board.length - 1;
if (i3 == (board.length)) i3 = 0;
if (j2 == -1) j2 = board[i].length - 1;
if (j3 == (board[i].length)) j3 = 0;
return new Cell[]{board[i2][j2], board[i2][j], board[i2][j3], board[i][j2], board[i][j3], board[i3][j2], board[i3][j], board[i3][j3]};

}

vous pouvez ensuite en boucle le tableau retourné et vérifier le nombre de ceux qui sont vivants et retour qui comptent.