---
# System prepended metadata

title: TP Algorithmie Game Of Life

---

# TP Algorithmie Game Of Life

## Ressources

 Exemple d'écriture d'une matrice (tableau à 2 dimensions, grille) 3x3 d'entiers en pseudo code:
 ```c#
 Entier[,] MATRICE = Entier[3,3]
 //Remplir l'élément (aussi appelé cellule) à la position (0,0) par 10.
 Entier[0,0] = 10
 //Remplir l'élément à la position (0,1) par 12.
 Entier[0,1] = 12
 //Accéder à l'élément (2,1) et l'afficher.
 Afficher MATRICE[2,1]
 ```
 Documentation sur les tableaux multidimensionnels en C#:
 https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/arrays/multidimensional-arrays

## Individuel

>On a dans notre code une matrice représentant une grille de vrai et de faux:
>```c#
>static bool[,] grid;
>```

### Elève 1 :

1 - Ecrire une fonction __*GenerateGrid*__ en pseudo code qui génére la grille (de taille x et y entiers donnés en entrée) et la remplie de valeurs aléatoires (vrai ou faux).

2 - Traduire en C#.

### Elève 2 :

1 - Ecrire en pseudo code une fonction __*GetNumberOfNeighboursAlive*__ qui prenne en entrée les coordonnées entières x et y d'un élément de la grille. Elle devra __retourner__ le nombre de voisins (cotés et diagonales, donc parmis 8) dont la valeur est vrai.

2 - Traduire en C#.

### Elève 3 :

1 - Ecrire en pseudo code une fonction __*DrawGame*__ qui dessine la grille dans la console. Les éléments *vrai* seront représentés par __\*__ et les éléments *faux* par un espace (on utilise Console.WriteLine() comme d'habitude). On ajoutera également un espace entre chaque élément pour plus de lisibilité.

>Exemple pour une matrice 5x5
>```
>   * *   * 
>   *   * * 
>       *   
>     *     
> * *     * 
>```

2 - Traduire en C#.

## Groupe

On veut réaliser un __*Game of Life*__: https://en.wikipedia.org/wiki/Conway%27s_Game_of_Life
>Le jeu de la vie est un « jeu à zéro joueur », puisqu'il ne nécessite pas l'intervention du joueur lors de son déroulement. Il s’agit d’un automate cellulaire, un modèle où chaque état conduit mécaniquement à l’état suivant à partir de règles pré-établies.
>
>Le jeu se déroule sur une grille à deux dimensions, théoriquement infinie (mais de longueur et de largeur finies et plus ou moins grandes dans la pratique), dont les cases — qu’on appelle des « cellules », par analogie avec les cellules vivantes — peuvent prendre deux états distincts : « vivante » ou « morte ».
>
>Une cellule possède huit voisins, qui sont les cellules adjacentes horizontalement, verticalement et diagonalement.
>
>À chaque étape, l’évolution d’une cellule est entièrement déterminée par l’état de ses huit voisines de la façon suivante :
>* Une cellule morte possédant exactement trois voisines vivantes devient vivante (elle naît).
>* Une cellule vivante possédant deux ou trois voisines vivantes le reste, sinon elle meurt.

Voici le main en C# pour le réaliser:
```c#
const int WIDTH = 20;
const int HEIGHT = 20;
const int FRAMERATE = 5;
static bool[,] grid;
static void Main(string[] args)
{
    GenerateGrid(WIDTH,HEIGHT);
    int step = 0;
    while (true)
    {
        Console.Clear();
        Console.WriteLine($"Step : {step}");
        DrawGame();
        Grow();
        step++;
        Thread.Sleep(1000 / FRAMERATE);
    }
}    
```

1 - Ecrire la fonction __*Grow*__, qui va faire evoluer la grille vers l'état suivant selon les règles du jeu.
*Attention à ne pas faire évoluer la grille au fur et à mesure. On doit détérminer la nouvelle valeur de chaque cellule de la grille avant d'appliquer toutes les modifications d'un coup à la grille. Autrement, les premières cellules modifiées pourrait avoir un impacte sur leurs voisines.*

2 - Vérifier que le jeu fonctionne en mettant en commun toutes vos fonctions, debugger autrement.

![Exemple rendu final](https://i.imgur.com/4aRUc8V.gif)

