using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading; using System.Threading.Tasks; namespace SoloLearn { ///

/// Programme de test pour le Jeu de la vie ///

class Program { static void Main(string[] args) { Console.CursorVisible = false; int pourcentageVivantes = 35; int largeur = Console.WindowWidth - 1; int hauteur = Console.WindowHeight - 1; AutomateJeuVie jeu = new AutomateJeuVie(largeur, hauteur, pourcentageVivantes); jeu.Initialiser(); while (!Console.KeyAvailable) { Console.SetCursorPosition(0, 0); jeu.Evoluer(); for (int j = 0; j < jeu.Hauteur; j++) { for (int i = 0; i < jeu.Largeur; i++) { char cellule = '\0'; switch (jeu.Cellules[i, j]) { case AutomateJeuVie.EtatCellule.Morte: cellule = ' '; break; case AutomateJeuVie.EtatCellule.Mourante: cellule = '-'; break; case AutomateJeuVie.EtatCellule.Naissante: cellule = '.'; break; case AutomateJeuVie.EtatCellule.Vivante: cellule = 'O'; break; default: cellule = '?'; break; } Console.Write(cellule); } Console.WriteLine(); } Console.Write("Génération : {0} cellules : {1}", jeu.Generation, jeu.NombreVivantes); Thread.Sleep(10); } } } ///

/// Classe de l'objet qui initialise les cellules et les faient évoluer. ///

class AutomateJeuVie { ///

/// EtatCellule détermine une liste d'énumération possible pour les cellules qui peut être utilisé comme un type de variable. ///

public enum EtatCellule { Morte, Vivante, Mourante, Naissante }; private int largeur; private int hauteur; private int pourcentageVivantes; private EtatCellule[,] cellules; private Random aleatoire = new Random(); private int nombreVivantes; private int generation; private bool etape = false; ///

/// Constructeur. ///

/// Largeur de la fenêtre défini dans le Main(). /// Hauter de la fenêtre défini dans le Main(). /// Pourcentage du nombre de vivante défini dans le Main(). public AutomateJeuVie(int largeur, int hauteur, int pourcentageVivantes) { this.largeur = largeur; this.hauteur = hauteur; this.PourcentageVivantes = pourcentageVivantes; generation = 0; } ///

/// Initialise le nombre de cellule vivante ou morte au début. ///

public void Initialiser() { cellules = new EtatCellule[largeur, hauteur]; for (int j = 0; j < hauteur; j++) { for (int i = 0; i < largeur; i++) { ///

/// Vérifie si le nombre de cellules vivantes est plus petit ou égal au pourcentage de vivantes. ///

if (aleatoire.Next(1, 101) <= PourcentageVivantes) { cellules[i, j] = EtatCellule.Vivante; } else { cellules[i, j] = EtatCellule.Morte; } } } } ///

/// Calcule le nombre de voisin autour de la cellule précisé. ///

/// La cellule en "x" du moment présent. /// La cellule en "y" du moment présent. /// private int CalculerVoisins(int x, int y) { int nbVoisins = 0; for (int j = y - 1; j <= y + 1; j++) { for (int i = x - 1; i <= x + 1; i++) { ///

///Vérifie si la cellule est dans la console ou non. ///

if ((i >= 0 && i < largeur) && (j >= 0 && j < hauteur)) { ///

///Vérifie si la cellule est vivante ou mourante pour la calculer comme voisin. ///

if (cellules[i, j] == EtatCellule.Vivante || cellules[i, j] == EtatCellule.Mourante) { ///

///Vérifie que la cellule elle même ne se compte pas comme voisin. ///

if (!(x == i && y == j)) { nbVoisins++; } } } } } ///

///retourne le nombre de voisins calculer. ///

return nbVoisins; } ///

/// Détermine si la cellule reste vivante, devient mourrante ou si elle devient naissante. ///

private void DeterminerCellule() { for (int j = 0; j < hauteur; j++) { for (int i = 0; i < largeur; i++) { if ((CalculerVoisins(i, j) < 2 || CalculerVoisins(i, j) > 3) && cellules[i, j] == EtatCellule.Vivante) { cellules[i, j] = EtatCellule.Mourante; } else if (CalculerVoisins(i, j) == 3 && cellules[i, j] == EtatCellule.Morte) { cellules[i, j] = EtatCellule.Naissante; } else if ((CalculerVoisins(i, j) == 2 || CalculerVoisins(i, j) == 3) && cellules[i, j] == EtatCellule.Vivante) { cellules[i, j] = EtatCellule.Vivante; } } } } ///

/// Applique les cellules mourrantes en mortes et les cellules naissantes en vivantes. ///

private void Appliquer() { nombreVivantes = 0; for (int j = 0; j < hauteur; j++) { for (int i = 0; i < largeur; i++) { if (cellules[i, j] == EtatCellule.Naissante) { cellules[i, j] = EtatCellule.Vivante; } else if (cellules[i, j] == EtatCellule.Mourante) { cellules[i, j] = EtatCellule.Morte; } if (cellules[i, j] == EtatCellule.Vivante) { nombreVivantes++; } } } } ///

/// Applique les méthodes DéternimerCellules() et Appliquer() en leur donnant un intervalle en utilisant le bool etape. ///

public void Evoluer() { if (etape == false) { DeterminerCellule(); etape = true; } else if (etape == true) { Appliquer(); etape = false; generation++; } } ///

/// Propriété du champs largeur qui peut-être utilisé dans le Main(). ///

public int Largeur { get { ///

///Retourne la valeur du champ largeur calculer dans cette classe à l'autre classe. ///

return largeur; } set { largeur = value; } } ///

/// Propriété du champs hauteur qui peut-être utilisé dans le Main(). ///

public int Hauteur { get { ///

///Retourne la valeur du champ hauteur calculer dans cette classe à l'autre classe. ///

return hauteur; } set { hauteur = value; } } ///

/// Propriété du champs pourcentageVivantes qui peut-être utilisé dans le Main(). ///

public int PourcentageVivantes { get { ///

///Retourne la valeur du champ pourcentageVivantes calculer dans cette classe à l'autre classe. ///

return pourcentageVivantes; } set { pourcentageVivantes = value; } } ///

/// Propriété du champs nombreVivantes qui peut-être utilisé dans le Main() pour définir la quantité. ///

public int NombreVivantes { get { ///

///Retourne la valeur du champ nombreVivantes calculer dans cette classe à l'autre classe. ///

return nombreVivantes; } } ///

/// Propriété du champs generation qui peut-être utilisé dans le Main() pour définir la quantité. ///

public int Generation { get { ///

///Retourne la valeur du champ generation calculer dans cette classe à l'autre classe. ///

return generation; } } ///

/// Propriété du champs cellules qui peut-être utilisé dans le Main() pour trouver l'état des cellules. ///

public EtatCellule[,] Cellules { get { ///

///Retourne la valeur du champ cellules définient dans cette classe à l'autre classe. ///

return cellules; } } } }