[DEFI Java] Le jeu de la vie

Random rnd = new Random();
rnd.nextDouble();

Random rnd = new Random();
rnd.nextFloat();

Random rnd = new Random();
int var = rnd.nextInt()%2;

nextInt(int n);

Random rnd = new Random();
int var = rnd.nextInt(int 2);

// jeu de la vie
public class JeuDeLaVie
{
// on commence par la methode qui remplira le tableau

public static void remplir_random_etat_courant(int[][][]T , int nbr)
{
  for(int i=1, i< nbr ; i++)
   {
    T[(int)(Math.random()*100)+1][(int)(Math.random()*100)+1][0]=1;
   }
}// fin de remplir_random_etat_courant

// debut affichage:
public static void afficheage(int [][][]T , int tranche)
{
  System.out.print(" ");
  for(int i=1 ; i<=100; i++)
  {
     for( int j=1 ; j<=100 ; j++)
     {
       if(T[i][j][tranche]==1)
        {
         System.out.print("*");
        }
        else
        {
         System.out.print(" ");
        }
      }// fin for j
    System.out.print("\n");
  }//fin for i
}// fin affichage

//debut evolution
public static void evoluer(int [][][],int i, int j , int courant,int suivant)
{
  int nbr_voisines=T[i-1][j-1][courant]+T[i-1][j][courant]+T[i-1][j+1][courant]+T[i][j+1][courant]+T[i+1][j+1][courant]+T[i+1][j][courant]+T[i+1][j-1][courant]+T[i][j-1][courant];
   if(nbr_voisines==2 || nbr_voisine==3)
    {
     T[i][j][suivant]=T[i][j][courant];
    }
    if(nbr_voisine < 2)
    {
     T[i][j][suivant]=0;
     }
     if (nbr_voisine > 3)
     {
     T[i][j][suivant]=0;
     }
    if(nbr_voisine ==3)
     {
     T[i][j][suivant]=1;
     }
}// fin de evoluer

//le main
piblic static void main(String args[])
{
  int [][][]T;
  T=new int [102][102][2];// 102 au lieu de 100 c'est pour simplifier l'evolution
  int courant=0;
  int suivant=1;

  remplir_random_etat_courant(T,200);// 200= nbr de cellule au depart
  affichage(T,0);//0=etat courant
  for(int cycle=0 ; cycle < 15 ; cycle++) // 15 ou + a vous de voir
  {
     for(int i=1 ; i <=100 ; i++)
     {
        for(int j=1; j<=100 ; j++)
        {
           evoluer(T,i,j,courant,suivant);
         }
      }
      affichage (T,suivant);
     
      if(courant==0)
      {
       courant=1;
       suivant=0;
      }
      else
      {
       courant=0;
       suivant=1;
   }//fin cycle
}// fin main

}//fin class JeDeLaVie     

/*
 * Created on 5 déc. 2005
 */
package pllune.life;

import java.util.Random;

/**
 * @author pierrot
 * Cette classe met en oeuvre le jeu de la vie.
 * Un algorithme publié pour la première fois par un mathématicien de Cambridge, du nom de John Conway.
 * Lors de sa publication, par Martin Gardner, dans la revue Scientific American, en octobre 1970,
 * il s'imposa directement comme étant un des problèmes les plus fréquemment posés aux étudiants américains.
 * cf: smn.andre
 */
public class GenerateurDeVie {
       
        /*
         * ce tableau represente la zone de test du generateur de vie
         */     
        private boolean[][] bouillonDeCulture;
       
        /*
         * Ceci est le cache du bouillon de culture.
         * Il est nécessaire pour on doit similuer la simultaneité de l'evolution.
         * Or le bouillon de culture est un tableau, et il est parcouru de façon lineaire.
         */
        private boolean[][] cache;

        /**
         * Le constructeur de GenerateurDeVie
         * on initialise le terrain de test (ou bouillon de culture) et son cache
         * @param largeur la largeur du bouillon
         * @param hauteur la hauteur du bouillon
         */
        public GenerateurDeVie(int largeur, int hauteur){
                this.bouillonDeCulture = new boolean[largeur][hauteur];
                this.cache = new boolean[largeur][hauteur];
                this.reset();
        }
       
        /**
         * Cette methode genere des cellules aleatoirement dans le bouillon de culture.
         */
        public void reset(){
                Random rnd = new Random();
                for(int x = 0; x < this.bouillonDeCulture.length; x++){
                        for(int y = 0; y < this.bouillonDeCulture[x].length; y++){
                                this.bouillonDeCulture[x][y] = rnd.nextBoolean();
                        }
                }
        }
       
        /**
         * Cette methode permet de passer une etape de l'evolution des cellules.
         */
        public void genererUnePhase(){
                // Pour chaque cellules:
                for(int x = 0; x < this.bouillonDeCulture.length; x++){
                        for(int y = 0; y < this.bouillonDeCulture[x].length; y++){
                                int nbVoisine = new Case(x,y).getNbVoisine();
                                if(this.bouillonDeCulture[x][y]){
                                        // Si une cellule a moins de 2 voisines ell.e meurt
                                    // Si une cellule a plus de 3 voisines, elle meurt d'étouffement
                                        if(nbVoisine < 2 || nbVoisine > 3){
                                                this.cache[x][y] = false;
                                        }
                                        // Si une cellule a 2 ou 3 voisines, elle survit
                                        else{
                                                this.cache[x][y] = true;
                                        }
                                       
                                }else{
                                        // Une cellule naît dans une case vide si cette case est entourée de précisement 3 cellules
                                        if(nbVoisine == 3){
                                                this.cache[x][y] = true;
                                        }
                                        // sinon, c'est effectivement une case vide.
                                        else{
                                                this.cache[x][y] = false;
                                        }
                                }
                        }
                }
                // on met a jour le bouillon de culture.
                this.bouillonDeCulture = this.cache;
        }
       
        /**
         * permet d'afficher une vue du bouillon de culture
         */
        public String toString(){
                String ret = "";
                for(int x = 0; x < this.bouillonDeCulture.length; x++){
                        for(int y = 0; y < this.bouillonDeCulture[x].length; y++){
                                // ouh pas beau le code la: oui je sais, mais c'est parfois super pratique :D
                                ret += (this.bouillonDeCulture[x][y]?"1":"0")+"|";
                        }
                        ret += "\n";
                }
                return ret;
        }
       
        /**
         * Cette methode permet de recuperer le bouillon de culture
         * @return
         */
        public boolean[][] getBouillonDeCulture() {
                return this.bouillonDeCulture;
        }
       
               
        /**
         *
         * @author pierrot
         *
         * Cette classe interne permet de definir un Point (un couple de coordonnées).
         * Elle permet aussi de tester le contenu de cette case.
         */
        class Case{
               
                /*
                 * l'abscisse
                 */
                private int x;
               
                /*
                 * l'ordonnée
                 */
                private int y;
               
                /**
                 * @param x l'abscisse
                 * @param y l'ordonnée
                 */
                public Case(int x, int y) {
                        super();
                        this.x = x;
                        this.y = y;
                }
                /**
                 * @return Returns the x.
                 */
                public int getX() {
                        return x;
                }
               
                /**
                 * @param x The x to set.
                 */
                public void setX(int x) {
                        this.x = x;
                }
               
                /**
                 * @return Returns the y.
                 */
                public int getY() {
                        return y;
                }
               
                /**
                 * @param y The y to set.
                 */
                public void setY(int y) {
                        this.y = y;
                }
               
                /**
                 * Cette methode permet de verifier si il y a une cellule dans une donné.
                 * Nous sommes dans un monde torique. Donc il peu etre necessaire d'ajuster les coordonnées d'une case
                 * @return true si la case possede une cellule, false sinon
                 */
                public boolean possedeUneCellule(){
                        if(this.getX() >= bouillonDeCulture.length){
                                this.setX(this.getX()-bouillonDeCulture.length);
                        }
                        if(this.getX() < 0){
                                this.setX(bouillonDeCulture.length+this.getX());
                        }
                        if(this.getY() >= bouillonDeCulture[this.getX()].length){
                                this.setY(this.getY()- bouillonDeCulture[this.getX()].length);
                        }
                        if(this.getY() < 0){
                                this.setY( bouillonDeCulture[this.getX()].length+this.getY());
                        }
                        return bouillonDeCulture[this.getX()][this.getY()];
                       
                }
               
                /**
                 * Cette methode permet de definir le nombre de cellule contenu dans les cases voisines
                 * @return le nombre le voisine
                 */
                public int getNbVoisine(){
                        int nbVoisine = 0;
                        // on selectionne tout les point autour de p
                        Case[] casesVoisines = {
                                        new Case(this.getX()+1,this.getY()-1),
                                        new Case(this.getX()+1,this.getY()),
                                        new Case(this.getX()+1,this.getY()+1),
                                        new Case(this.getX(),this.getY()-1),
                                        new Case(this.getX(),this.getY()+1),
                                        new Case(this.getX()-1,this.getY()-1),
                                        new Case(this.getX()-1,this.getY()),
                                        new Case(this.getX()-1,this.getY()+1),
                                        };
                       
                        for(int i = 0; i < casesVoisines.length; i++){
                                // on verifie si les positions voisines possedes des cellules ou pas.
                                // nous sommes dans un monde torique donc on ajuste les coordonnées des points si elle depasse du tableau.
                                if(casesVoisines[i].possedeUneCellule()){
                                        nbVoisine++;
                                }
                        }
                       
                        return nbVoisine;
                }
               
        }
}