S'il vous plaît aider avec ma mise en œuvre de base de Java du jeu de la vie de Conway

Question

J'ai passé un certain temps à essayer d'écrire un programme pour mettre en œuvre le jeu de la vie de Conway - Link with more info.. Je suis quelques guides en ligne et a donné la majorité des fonctions. J'ai écrit les méthodes "next" et "neighbors" ci-dessous. Quelqu'un pourrait-il me dire si ce sont de bonnes implémentations, et comment elles pourraient être améliorées s'il vous plaît?

Le but de l'exercice était de ne pas modifier ou changer les autres méthodes et d'écrire simplement 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 au if - else dans la boucle suivante. En outre, stocker 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 les conditions (OOB) hors limite. Il tue la performance. Mieux vaut utiliser le mécanisme wrap-around pour traiter votre tableau comme une sphère afin de ne pas rencontrer d'OOB 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.