#3

/*
Programmeuse: Medina Mohamed
Programmeur: Marc-Antoine Cléroux
date: 25 Octobre 2017
cours:IFT 1015
travail: TP1
programme contenant un ensemble de définitions de fonctions qui permettent de générer
des labyrinthes et les dessiner sur la fenêtre de dessin de codeBoot.
*/

//fonction iota()
var iota = function(n){
    if (n>=0 && n%1==0){
        var tab = Array(n);
        for (var i = 0; i < tab.length; i++){
            tab[i] = i;
        }
        return tab;
    }
};

//fonction contient()
var contient = function(tab, x){
    return tab.includes(x);
};

// function ajouter()
var ajouter = function(tab, x){
    if (contient(tab, x) == false)
        tab.push(x);
    return tab;
};

// function retirer()
var retirer = function(tab, x){
    if (contient(tab, x) == false)
        return tab;
    else
        for (var i = 0; i < tab.length; i++){
            if (x == tab[i]){
                var tab1 = [];
                return tab1.concat(tab.slice(0,i),tab.slice(i+1,tab.length+1));
            }
        }
};

// fonction voisins()
var voisins = function(x, y, nx, ny){
    var tab = Array(nx);
        for (var i = 0; i < nx; i++){
            tab[i] = Array(ny);
            for (var j = 0; j < ny; j++){
                tab[i][j] = (i)+(j)*(nx);
            }
        }
    var tab_retour = [];
    if (y != 0){
        tab_retour.push(tab[x][y-1]);}
    if (x != 0)
        tab_retour.push(tab[x-1][y]);
    if (x != tab.length-1)
        tab_retour.push(tab[x+1][y]);
    if (y != tab[1].length-1)
        tab_retour.push(tab[x][y+1]);
    return tab_retour;
};

var tab_to_front = function(x, y, nx, ny,cave, front){
        var tab = voisins(x, y, nx, ny);
        for (var i = 0; i < tab.length; i++){
            if (contient(cave, tab[i])==false){
                ajouter(front, tab[i]);
            }
        }
        return(front);
    };

var dessins = function(mursH, mursV, nx, ny, pas){

	//amene la tortue en haut a gauche pour premiere ligne horizontal
    pu(); fd((ny*pas/2),(nx/2)*pas); rt(90);
    /*dessin des murs horizontaux*/

    for (var i = 0; i<ny+1; i++){
        for(var j=0; j<nx; j++){
            if (contient(mursH, j+nx*i)){
                pd();
                fd(pas);
                pu();
            }
            else{
                fd(pas);
            }
        }
        bk(nx*pas);
        bk(0,pas);
    }

    fd(0,(ny+1)*pas); //pour ramener la tortue en haut a gauche quand tous les lignes hori sont dessiner
    lt(90);// pour sappreter a dessiner les lignes verticauz


    /*Dessin murs verticaux*/
    for (var i = 0; i<ny; i++){
        for(var j=0; j<nx+1; j++){
            if (contient(mursV,j+(nx+1)*i)){
                pd();
                bk(pas);
                pu();
                fd(pas);
            }
            bk(0,pas);
        }
        fd(-pas,(nx+1)*pas);
    }
};

var laby = function(nx, ny, pas){
    var tab_murs = Array(nx*ny);
    for (var i = 0; i < nx; i++){
        for (var j = 0; j < ny; j++){
            tab_murs[i+nx*j] = Array(4);
            tab_murs[i+nx*j][0] = i + j * nx;//calcul N
            tab_murs[i+nx*j][1] = 1 + i + j * (nx + 1);//calcul E
            tab_murs[i+nx*j][2] = i + (j + 1) * nx;//calcul S
            tab_murs[i+nx*j][3] = i + j * (nx + 1);//calcul O
        }
    }

    var mursH = iota(nx * (ny+1));//créé un tableau contenant tous les # de murs horizontaux
    mursH = retirer(mursH, 0); // on enlève le premier mur par défaut
    mursH = retirer(mursH, nx * (ny+1)-1); // on enlève le dernier murs par défaut
    var mursV = iota(ny * (nx+1));//créé un tableau contenant tous les # de murs verticaux

    var cave = []; //L’ensemble cave est l’ensemble des cellules qui ont été mis dans la cavité par l’algorithme.
    var front = [];   //L’ensemble front est l’ensemble des cellules qui sont voisines des cellules dans la cavité (mais pas dans la cavité)
    var case_ran = Math.floor(Math.random()*(nx*ny+1)); //retourner les coordonnee de la case random?

    front = tab_to_front(case_ran%nx, Math.floor(case_ran/nx), nx, ny, cave, front);
    cave = ajouter(cave, case_ran);
    front = retirer(front, case_ran);

    while (front.length != 0){
        var random_voi = front[Math.floor(Math.random()*front.length)]; // prendre un voisin de la cavité au hasard
        var check_voi = voisins(random_voi%nx, Math.floor(random_voi/nx), nx, ny);

        boucle_mur:
        for (var i = 0; i< check_voi.length; i++){
            for (var j = 0; j < cave.length; j++){

                if (check_voi[i] == cave[j]){
                    if (tab_murs[random_voi][0] == tab_murs[cave[j]][2]){
                        mursH = retirer(mursH, tab_murs[cave[j]][2]);
                    }
                    else if (tab_murs[random_voi][1] == tab_murs[cave[j]][3]){
                        mursV = retirer(mursV, tab_murs[cave[j]][3]);
                    }
                    else if (tab_murs[random_voi][2] == tab_murs[cave[j]][0]){
                        mursH = retirer(mursH, tab_murs[cave[j]][0]);
                    }
                    else{
                        mursV = retirer(mursV, tab_murs[cave[j]][1]);
                    }
                    break boucle_mur;
                }
            }
        }

        front = tab_to_front(random_voi%nx, Math.floor(random_voi/nx), nx, ny, cave, front);
        cave = ajouter(cave, random_voi);
        front = retirer(front, random_voi);
    }
    cs();
    dessins(mursH,mursV,nx,ny,pas);

};

var test = function (){
    assert(contient([9,2,5],2) == true);
    assert(contient([9,2,5],4) == false);
    assert(ajouter([9,2,5], 2) == "9,2,5");
    assert(ajouter([9,2,5], 4) == "9,2,5,4");
    assert(retirer([9,2,5], 2) == "9,5");
    assert(retirer([9,2,5], 4) == "9,2,5");
    assert(voisins(7, 2, 8, 4) == "15,22,31");

};
test();