/**
* cree par : Marc-Andre Piche
* 783722
*
* Game of Life type Griffeath --
* automate cellulaire qui passe au prochain etat
* quand au moins une (ou min) cellule(s) voisine(s) a cet etat.
*
* exemple pour 3 etats, la cellule (3) du centre passe a (1)
* puisqu elle a une cellule (1) dans son voisinage:
*
* 2 1 1 (moore) 3 2 1
* 1 3 1 --> 2 1 1
* 1 1 1 (batch) 1 1 1
*/


// deux jeux de couleurs: 4 et 10

var colors_4 = [{r:255, g:51, b:51}, // rouge
{r:255, g:153, b:51}, // orange
{r:255, g:255, b:51}, // jaune
{r:255, g:229, b:204}]; // rose

var colors_10 = [{r:241, g:148, b:138},
{r:195, g:135, b:211},
{r:127, g:179, b:213},
{r:118, g:215, b:196},
{r:247, g:220, b:111},
{r:229, g:152, b:102},
{r:191, g:201, b:202},
{r:133, g:146, b:158},
{r:28, g:40, b:51},
{r:33, g:97, b:140}];

// variables du cahier des charges:
var colors = 4; // nombre d etats
var init ="random"; // distribution des etats
var voisinage = "moore"; // evaluation selon Moore ou VonNeumann
var evolution= "online"; // methode de mise a jour des etats
var n = 20; // nombre de lignes
var m = 50; // nombre de colonnes
var min =1; // valeur entre 0 et 8


function createTableau(nbLines, nbColumns) { //code fourni en classe: creer un tableau
var g = new Array(nbLines);
for ( var i=0; i g[i] = new Array(nbColumns);
return g;
}

function fillMatrice(tableau) { //rempli le tableau d etats: au hasard ou uniforme(1)
switch (init) {
case "uniform":
for (var k = 0; k < tableau.length; ++k)
tableau[k].fill(1); //rempli chaque cellule de la valeur (1)
break;
default : //case "random" par default
for (var i = 0; i < tableau.length; ++i)
for (var j = 0; j < tableau[i].length; j++)
tableau[i][j] = (Math.floor(Math.random() * colors)) + 1; // rempli chaque cellule d une valeur au hasard
break;
}
}

// variables globales additionelles:
var palette= colors_4; //pointeur des tableau de couleurs selon nb colors
var direction = [[-1,0],[0,-1],[0,1],[1,0],[-1,-1],[-1,1],[1,-1],[1,1]]; //tableau des 8 directions ordonnees pour verifier VonNeumann en premier
var marqueur = false; // indice de changement d une cellule /indice de continuite
var matrice= createTableau(n,m); //tableau des valeurs d etats par default
fillMatrice(matrice); //initialise les valeurs du tableau



function cellCheck(i,j,tableau,state) {
return i>= 0 && i= 0 && j }



function nextState(s) {
return ((s >= colors) ? 1 : s + 1); //retourne le prochaine etat du cycle
}


function evalCell(i,j,matrice) { // evalue une cellule et retourne sa nouvelle valeur
var count = 0;
var checkState= nextState(matrice[i][j]);//valeur de recherche : une cellule qui a l etat suivant
for (var a = 0; count !==min && (a < 4 || ((voisinage == "moore") && a < 8)); a++) { //parcours les 4 ou 8 directions (selon moore) jusqua ce qu il trouve min etat(s) recherches
count += +(cellCheck(i + direction[a][0], j + direction[a][1], matrice, checkState)); //evalue une direction et ajoute 1 si cellCheck est true
} if (count==min) {
marqueur = true; //indique qu une cellule a ete modifiee
return checkState;
}else return matrice[i][j]; //la cellule n est pas modifiee
}

function updateOnline(matrice){
for (var i=0; i for (var j=matrice[i].length-1; j>=0; j--) {
matrice[i][j] = evalCell(i, j,matrice);
setPixel(j,i,palette[matrice[i][j]-1]); //fonction codeboot d interface image: pixel selon l etat ij
}
}

function updateBatch(x,permuteTableau){
for (var i=0; i for (var j = permuteTableau[x][i].length - 1; j >= 0; j--){
permuteTableau[x^1][i][j] = evalCell(i,j,permuteTableau[x]); //place resultat evalue dans la 'matrice' alternative
}
}
}

function updateImage(matrice){ //mise a jour de tous les pixels
for (var i=0; i for (var j=0; j setPixel(j,i,palette[matrice[i][j]-1]); //fonction codeboot d interface image
}

//core function


function getCommandes(commandLine){ //separe la ligne de commande en tableau n x 2 [ind,val]
var tableauCommandes = commandLine.split(";");
for (var i=0; i tableauCommandes[i] = tableauCommandes[i].split("=");
}
return tableauCommandes;
}


function findCommandValue(str,tableau){ //cherche et retourne la valeur associee a une string**fonction accepte seulement les tableau n x 2
for (var i=0; i if (tableau[i].indexOf(str)!== -1) return tableau[i][(tableau[i].indexOf(str))^1]; // -- methode seulement pour les tableaux n x 2
return undefined;
}


function initCommands(tableau) { //**fonction accepte seulement les tableau n x 2
//extrait les valeurs associees au variables principales
var findcolors = findCommandValue("colors",tableau);
var findinit =findCommandValue("init",tableau);
var findvoisinage = findCommandValue("voisinage",tableau);
var findevolution= findCommandValue("evolution",tableau);
var findn = findCommandValue("n",tableau);
var findm = findCommandValue("m",tableau);
var findmin =findCommandValue("min",tableau);

//applique les valeurs trouves ou celles par default
(findcolors===undefined)? colors = 4tristefindcolors==="10")? colors = 10:colors = 4;
(findinit===undefined)? init ="random"tristefindinit === "uniform")? init ="uniform":init ="random";
(findvoisinage===undefined)? voisinage ="moore"tristefindvoisinage.toLowerCase() === "vonneumann")? voisinage ="vonneumann":voisinage ="moore";
(findevolution===undefined)? evolution ="online"tristefindevolution.toLowerCase() === "batch")? evolution ="batch":evolution ="online";
(findn===undefined)? n =20 tristeisNaN(+findn))? n =20:n =+findn;
(findm===undefined)? m =50 tristeisNaN(+findm))? m =50:m =+findm;

(findmin===undefined)? min =1 tristeisNaN(+findmin))? min =1:min =+findmin;
if (min < 0 ) min = -min; //converti une valeur negative
if (min > 8) min = 8 ; //max min = 8

(colors === 10)? palette= colors_10: palette= colors_4; //utilisez switch pour plus de 2 palettes

}

function play(commandLine) {


var tableauCommandes = (commandLine===undefined)? tableauCommandes = "": getCommandes(commandLine);
initCommands(tableauCommandes);
matrice= createTableau(n,m); //reinitialise les dimensions du tableau des valeurs d etats
fillMatrice(matrice); //reinitialise les valeurs du tableau


setScreenMode(m,n); //fonction codeboot d interface image
updateImage(matrice); //initialise l image au temps zero


switch (evolution) { //choix de mise a jour selon 'evolution'
case "online":
do {
marqueur = false;
updateOnline(matrice);
} while (marqueur);
break;
case "batch":
batchRun();
break;
}
}


function batchRun() { //creer un deuxieme tableau tampon et alterne avec la matrice originale pour faire la mise a jour
var altMatrice= createTableau(n,m); //solution alternative :considerez une copie des deux premieres lignes seulement pour un tres grand tableau: demande plus que calcul, mais moins de memoire
var permuteTableau=[matrice,altMatrice]; //ensemble des deux tableaux alternatifs
var x=0; //indice du tableau tampon
do {
marqueur = false;
updateBatch(x,permuteTableau);
//pause();
x ^= 1; //permute l indice des deux tableaux 1/0
updateImage(permuteTableau[x]);
} while (marqueur);
}