//------------------------------------------------------------------------------
// Map - Création de la matrice
//------------------------------------------------------------------------------

void    Create_Map()
 {
    int     x, y;
    char    c[1];                       // Lecture du caractère du fichier map
    FILE    *fp;                        // Fichier pour le rapport
    int     mattmp[100][100];           // Matrice de la map convertie                  | Create_Map(MAP)

    //---   Lecture du .map   ---\\

    if (!map)                                       // Si on a pas encore lu le .map
     {
        // Initialisation de la matrice
        for (x=0; x<=nb1+1; x++)
            for (y=0; y<=nb2+1; y++)
                mat[x][y]=0;
        if ((fp=fopen(map_name, "r"))==NULL) exit(0); // Si on peut pas l'ouvrir, on quitte
        else
         {
            fscanf (fp, "%d\n", &nb1);              // Le premier chiffre donne la hauteur
            fscanf (fp, "%d\n", &nb2);              // Le second chiffre donne la largeur
            for (x=0; x<=nb1+1; x++)
             {
                for (y=0; y<=nb2+1; y++)
                 {
                    // Si on est sur les bords, la matrice aura la valeur 0
                    if ((x==0) || (y==0) || (x==nb1+1) || ((x==nb1) && (y==nb2+1))) mat[x][y]=0;
                    else
                     {
                        fseek(fp, 0, SEEK_CUR);
                        fscanf(fp, "%c", &c);
                        if (c[0]=='*') mat[x][y]=1; // Sol
                        if (c[0]==' ') mat[x][y]=0; // Pas de sol
                        if (c[0]=='x')              // Définit un point de départ sans sol
                         {
                            move_rl=x*scal-0.5*scal;
                            run=y*scal-0.5*scal;
                            jump=0.5*scal;
                            mat[x][y]=0;
                         }
                        if (c[0]=='X')              // Définit un point de départ avec sol
                         {
                            move_rl=x*scal-0.5*scal;
                            run=y*scal-0.5*scal;
                            jump=0.5*scal;
                            mat[x][y]=1;
                         }
                     }
                 }
             }
         }
        fclose(fp);

        //---   Création d'un rapport.txt   ---\\

        if ((fp=fopen("rapport.txt", "w"))==NULL) exit(0); //erreur d'ouverture
        else
         {
            for (x=0; x<=nb1+1; x++)
             {
                for (y=0; y<=nb2+1; y++)
                 {
                    fprintf(fp, "%d", mat[x][y]);
                 }
                fprintf(fp, "\n");
             }
         }
        fprintf(fp, "\n\tPoint de départ : %d - %d", (int)run, (int)move_rl);
        fprintf(fp, "\n\tCase : %d - %d", (int)(run/scal+0.5), (int)(move_rl/scal+0.5));
        fprintf(fp, "\n\tTaille : %d - %d", nb1, nb2);
        fclose(fp);
        map=!map;                                   // On ne reliera plus le fichier .map
     }

    //---   Affichage de la map en polygones   ---\\  

    // Initialisation de la matrice
    for (x=0; x<=nb1+1; x++)
        for (y=0; y<=nb2+1; y++)
            mattmp[x][y]=mat[x][y];        

    if (m3D)
     {
        // EXPLICATIONS
        //
        // devant -> X : où on est | 0 : trou | 1 : sol | 2 : sol effacé par l'algo
        // 
        // 11111    Comme il y a un 0, les 2 seront effacés car on cherche les nombres sur la ligne
        // 11111    qui possède un 0. On fait pareil pour toutes les autres directions.
        // X1022
        // 11111

        // devant
        for (y=(int)(run/scal+1)+1; y<=nb2; y++)
            if (mattmp[(int)(move_rl/scal+1)][y-1]==0) mattmp[(int)(move_rl/scal+1)][y]=0;

        // derrière
        for (y=(int)(run/scal+1)-1; y>=1; y--)
            if (mattmp[(int)(move_rl/scal+1)][y+1]==0) mattmp[(int)(move_rl/scal+1)][y]=0;

        // haut
        for (x=(int)(move_rl/scal+1)-1; x>=1; x--)
            if (mattmp[x+1][(int)(run/scal+1)]==0) mattmp[x][(int)(run/scal+1)]=0;

        // bas
        for (x=(int)(move_rl/scal+1)+1; x<=nb1; x++)
            if (mattmp[x-1][(int)(run/scal+1)]==0) mattmp[x][(int)(run/scal+1)]=0;
/*
        // EXPLICATIONS
        //
        // diagonale haut droit -> X : où on est | 0 : trou | 1 : sol | 2 : sol effacé par l'algo
        // 
        // 11121    Comme il y a un 0 dans la diagonale, et un 0 en bas, le 2 sera effacé
        // 11001    qui possède un 0. On fait pareil pour tous les coins possibles.
        // X1111
        // 11111

        // diagonale haut droit
        for (x=int(move_rl/scal+1)-2; x>=1; x--)
            for (y=int(run/scal+1)+2; y<=nb2; y++)
                if ((mattmp[x+1][y-1]==0) && (x+y==int(run/scal+1)+int(move_rl/scal+1))) mattmp[x][y]=0;
                if ((mattmp[x+1][y-1]==0) && (x==int(move_rl/scal+1)-2)) mattmp[x][y]=0;
                if ((mattmp[x+1][y-1]==0) && (y==int(run/scal+1))) mattmp[x][y]=0;

        // diagonale bas droit
        for (x=int(move_rl/scal+1)+2; x<=nb1; x++)
            for (y=int(run/scal+1)+2; y<=nb2; y++)
                if ((mattmp[x-1][y-1]==0) && ((mattmp[x-1][y]==0))) mattmp[x][y]=0;

        // diagonale haut gauche
        for (x=int(move_rl/scal+1)-2; x>=1; x--)
            for (y=int(run/scal+1)-2; y>=1; y--)
                if ((mattmp[x+1][y+1]==0) && ((mattmp[x+1][y]==0))) mattmp[x][y]=0;

        // diagonale bas gauche
        for (x=int(move_rl/scal+1)+2; x<=nb1; x++)
            for (y=int(run/scal+1)-2; y>=1; y--)
                if ((mattmp[x-1][y+1]==0) && ((mattmp[x-1][y]==0))) mattmp[x][y]=0;
*/

        // EXPLICATIONS
        //
        // coin haut droit -> X : où on est | 0 : trou | 1 : sol | 2 : sol effacé par l'algo
        // 
        // 11121    Comme il y a un 0 dans la diagonale, et un 0 en bas, le 2 sera effacé
        // 11001    qui possède un 0. On fait pareil pour tous les coins possibles.
        // X1111
        // 11111

        // coin haut droit
        for (x=(int)(move_rl/scal+1)-2; x>=1; x--)
            for (y=(int)(run/scal+1)+2; y<=nb2; y++)
             {
                if ((mattmp[x+1][y-1]==0) && (x+y==(int)(run/scal+1)+(int)(move_rl/scal+1))) mattmp[x][y]=0;
                if ((mattmp[x+1][y-1]==0) && (x==(int)(move_rl/scal+1)-2)) mattmp[x][y]=0;
                if ((mattmp[x+1][y-1]==0) && (y==(int)(run/scal+1)+2)) mattmp[x][y]=0;
                if ((mattmp[x+1][y-1]==0) && ((mattmp[x+1][y]==0))) mattmp[x][y]=0;
             }

        // coin bas droit
        for (x=(int)(move_rl/scal+1)+2; x<=nb1; x++)
            for (y=(int)(run/scal+1)+2; y<=nb2; y++)
             {
                if ((mattmp[x-1][y-1]==0) && (x-y==(int)(run/scal+1)-(int)(move_rl/scal+1))) mattmp[x][y]=0;
                if ((mattmp[x-1][y-1]==0) && (x==(int)(move_rl/scal+1)+2)) mattmp[x][y]=0;
                if ((mattmp[x-1][y-1]==0) && (y==(int)(run/scal+1)+2)) mattmp[x][y]=0;
                if ((mattmp[x-1][y-1]==0) && ((mattmp[x-1][y]==0))) mattmp[x][y]=0;
             }

        // coin haut gauche
        for (x=(int)(move_rl/scal+1)-2; x>=1; x--)
            for (y=(int)(run/scal+1)-2; y>=1; y--)
             {
                if ((mattmp[x+1][y+1]==0) && (x-y==(int)(run/scal+1)-(int)(move_rl/scal+1))) mattmp[x][y]=0;
                if ((mattmp[x+1][y+1]==0) && (x==(int)(move_rl/scal+1)-2)) mattmp[x][y]=0;
                if ((mattmp[x+1][y+1]==0) && (y==(int)(run/scal+1)-2)) mattmp[x][y]=0;
                if ((mattmp[x+1][y+1]==0) && ((mattmp[x+1][y]==0))) mattmp[x][y]=0;
             }

        // coin bas gauche
        for (x=(int)(move_rl/scal+1)+2; x<=nb1; x++)
            for (y=(int)(run/scal+1)-2; y>=1; y--)
             {
                if ((mattmp[x-1][y+1]==0) && (x+y==(int)(run/scal+1)+(int)(move_rl/scal+1))) mattmp[x][y]=0;
                if ((mattmp[x-1][y+1]==0) && (x==(int)(move_rl/scal+1)+2)) mattmp[x][y]=0;
                if ((mattmp[x-1][y+1]==0) && (y==(int)(run/scal+1)-2)) mattmp[x][y]=0;
                if ((mattmp[x-1][y+1]==0) && ((mattmp[x-1][y]==0))) mattmp[x][y]=0;
             }

        // EXPLICATIONS
        //
        // angle droit haut droit -> X : où on est | 0 : trou | 1 : sol | 2 : sol effacé par l'algo
        // 
        // 11111    Comme il y a deux 0, ils forment un mur. Le 2 sera effacé.
        // 10211    On fait pareil pour tous les angles droits possibles.
        // X1011
        // 11111

        // angle droit haut droit
        for (x=(int)(move_rl/scal+1); x>=1; x--)
            for (y=(int)(run/scal+1); y<=nb2; y++)
                if ((mattmp[x][y]==0) && (mattmp[x-1][y-1]==0)) mattmp[x-1][y]=0;

        // angle droit bas droit
        for (x=(int)(move_rl/scal+1); x<=nb1; x++)
            for (y=(int)(run/scal+1); y<=nb2; y++)
                if ((mattmp[x][y]==0) && (mattmp[x+1][y-1]==0)) mattmp[x+1][y]=0;

        // angle droit haut gauche
        for (x=(int)(move_rl/scal+1); x>=1; x--)
            for (y=(int)(run/scal+1); y>=1; y--)
                if ((mattmp[x][y]==0) && (mattmp[x-1][y+1]==0)) mattmp[x-1][y]=0;

        // angle droit bas gauche
        for (x=(int)(move_rl/scal+1); x<=nb1; x++)
            for (y=(int)(run/scal+1); y>=1; y--)
                if ((mattmp[x][y]==0) && (mattmp[x+1][y+1]==0)) mattmp[x+1][y]=0;
    }

    for (x=1; x<=nb1; x++)
     {
        for (y=1; y<=nb2; y++)
         {

            // vérifie si la case actuelle (3) comporte un 1
            if (mattmp[x][y]==1)
             {
            // dessine le sol
            glBindTexture(GL_TEXTURE_2D, Name[13]);
            glBegin(GL_QUADS);
                glTexCoord2i(0,0);glVertex3i(y-1,0,x-1);
                glTexCoord2i(1,0);glVertex3i(y-1,0,x);
                glTexCoord2i(1,1);glVertex3i(y,0,x);
                glTexCoord2i(0,1);glVertex3i(y,0,x-1);
            glEnd();
            // dessine le plafond - peut être retiré à cause du ciel
            glBindTexture(GL_TEXTURE_2D, Name[3]);
            glBegin(GL_QUADS);
                glTexCoord2i(0,0);glVertex3i(y,1,x-1);
                glTexCoord2i(1,0);glVertex3i(y,1,x);
                glTexCoord2i(1,1);glVertex3i(y-1,1,x);
                glTexCoord2i(0,1);glVertex3i(y-1,1,x-1);
            glEnd();
                // vérifie si la case du dessus (1) comporte un 0
                if (mattmp[x-1][y]==0)
                 {
            glBindTexture(GL_TEXTURE_2D, Name[12]);// Texture de Grille
            glBegin(GL_QUADS);
                glTexCoord2i(0,0);glVertex3i(y-1,0,x-1);
                glTexCoord2i(1,0);glVertex3i(y,0,x-1);
                glTexCoord2i(1,1);glVertex3i(y,1,x-1);
                glTexCoord2i(0,1);glVertex3i(y-1,1,x-1);
                 }
            glEnd();
                // vérifie si la case de gauche (2) comporte un 0
                if (mattmp[x][y-1]==0)
                 {
            glBindTexture(GL_TEXTURE_2D, Name[12]);
            glBegin(GL_QUADS);
                glTexCoord2i(0,0);glVertex3i(y-1,0,x);
                glTexCoord2i(1,0);glVertex3i(y-1,0,x-1);
                glTexCoord2i(1,1);glVertex3i(y-1,1,x-1);
                glTexCoord2i(0,1);glVertex3i(y-1,1,x);
            glEnd();
                 }
                // vérifie si la case de droite (4) comporte un 0
                if (mattmp[x][y+1]==0)
                 {
            glBindTexture(GL_TEXTURE_2D, Name[12]);
            glBegin(GL_QUADS);                
                glTexCoord2i(0,0);glVertex3i(y,0,x-1);
                glTexCoord2i(1,0);glVertex3i(y,0,x);
                glTexCoord2i(1,1);glVertex3i(y,1,x);
                glTexCoord2i(0,1);glVertex3i(y,1,x-1);
            glEnd();
                 }
                // vérifie si la case du bas (5) comporte un 0
                if (mattmp[x+1][y]==0)
                 {
            glBindTexture(GL_TEXTURE_2D, Name[12]);
            glBegin(GL_QUADS);
                glTexCoord2i(0,0);glVertex3i(y,0,x);
                glTexCoord2i(1,0);glVertex3i(y-1,0,x);
                glTexCoord2i(1,1);glVertex3i(y-1,1,x);
                glTexCoord2i(0,1);glVertex3i(y,1,x);
            glEnd();
                 }  // fin if
             }  // fin if
         }  // fin for
     }  // fin for
 }

//------------------------------------------------------------------------------
// Explications
//------------------------------------------------------------------------------
//
//    1    Si la case actuelle (3) de la matrice comporte un 0, on ne dessine
//  2 3 4  pas de sol. Sinon, on crée un sol et on vérifie les cases adjacentes.
//    5    Si elles comporte des 0, on crée un mur à chaque fois.
//
//  avec ce fichier :        on obtient la matrice:
//    5                        0000000 
//    5                        0111110
//    *****                    0101010
//    * * *                    0101010
//    * * *                    0101010
//    * * *                    0111110
//    *****                    0000000

//------------------------------------------------------------------------------
// Map - Affiche un ciel
//------------------------------------------------------------------------------

void    Draw_Ciel()
 {
    glBindTexture(GL_TEXTURE_2D, Name[6]);
    glPushMatrix();
    glTranslatef(nb2/2, cos(2*roll)*5, sin(2*roll)*(nb1/2)+nb1/2);
    gluSphere(g_quadratic,0.5f,32,32);              // Draw A Sphere With A Radius Of 1 And 16 Longitude And 16 Latitude Segments
    glPopMatrix();

    // Ciel
        // devant
    glBindTexture(GL_TEXTURE_2D, Name[21]);
    glBegin(GL_QUADS);
        glTexCoord2f(0,0);glVertex3i(-10,-10,-10);
        glTexCoord2f(1,0);glVertex3i(nb2+10,-10,-10);
        glTexCoord2f(1,1);glVertex3i(nb2+10,10,-10);
        glTexCoord2f(0,1);glVertex3i(-10,10,-10);
    glEnd();
        // droite
    glBindTexture(GL_TEXTURE_2D, Name[24]);
    glBegin(GL_QUADS);
        glTexCoord2f(1,0);glVertex3i(nb2+10,-10,nb1+10);
        glTexCoord2f(0,0);glVertex3i(nb2+10,-10,-10);
        glTexCoord2f(0,1);glVertex3i(nb2+10,10,-10);
        glTexCoord2f(1,1);glVertex3i(nb2+10,10,nb1+10); 
    glEnd();
        // derriere
    glBindTexture(GL_TEXTURE_2D, Name[23]);
    glBegin(GL_QUADS);
        glTexCoord2f(0,0);glVertex3i(nb2+10,-10,nb1+10);
        glTexCoord2f(1,0);glVertex3i(-10,-10,nb1+10);
        glTexCoord2f(1,1);glVertex3i(-10,10,nb1+10);
        glTexCoord2f(0,1);glVertex3i(nb2+10,10,nb1+10);
    glEnd();
        // gauche
    glBindTexture(GL_TEXTURE_2D, Name[22]);
    glBegin(GL_QUADS);
        glTexCoord2f(0,0);glVertex3i(-10,-10,nb1+10);
        glTexCoord2f(1,0);glVertex3i(-10,-10,-10);
        glTexCoord2f(1,1);glVertex3i(-10,10,-10);
        glTexCoord2f(0,1);glVertex3i(-10,10,nb1+10);
    glEnd();
        // haut
    glBindTexture(GL_TEXTURE_2D, Name[25]);
    glBegin(GL_QUADS);
        glTexCoord2f(0,0);glVertex3i(-10,10,-10);
        glTexCoord2f(1,0);glVertex3i(nb2+10,10,-10);
        glTexCoord2f(1,1);glVertex3i(nb2+10,10,nb1+10);
        glTexCoord2f(0,1);glVertex3i(-10,10,nb1+10);
    glEnd();
        // bas
    glBindTexture(GL_TEXTURE_2D, Name[26]);
    glBegin(GL_QUADS);
        glTexCoord2f(0,0);glVertex3i(-10,-10,nb1+10);
        glTexCoord2f(1,0);glVertex3i(nb2+10,-10,nb1+10);
        glTexCoord2f(1,1);glVertex3i(nb2+10,-10,-10);
        glTexCoord2f(0,1);glVertex3i(-10,-10,-10);
    glEnd();
 }  // fin func


/*
    // Ciel
    glBindTexture(GL_TEXTURE_2D, Name[2]);
    glBegin(GL_QUADS);
        // devant
        glTexCoord2f(0-roll,0-roll);glVertex3i(-10,-10,-10);
        glTexCoord2f(1-roll,0-roll);glVertex3i(nb2+10,-10,-10);
        glTexCoord2f(1-roll,1-roll);glVertex3i(nb2+10,10,-10);
        glTexCoord2f(0-roll,1-roll);glVertex3i(-10,10,-10);
        // droite
        glTexCoord2f(1-roll,0-roll);glVertex3i(nb2+10,-10,nb1+10);
        glTexCoord2f(0-roll,0-roll);glVertex3i(nb2+10,-10,-10);
        glTexCoord2f(0-roll,1-roll);glVertex3i(nb2+10,10,-10);
        glTexCoord2f(1-roll,1-roll);glVertex3i(nb2+10,10,nb1+10); 
        // derriere
        glTexCoord2f(0-roll,0-roll);glVertex3i(nb2+10,-10,nb1+10);
        glTexCoord2f(1-roll,0-roll);glVertex3i(-10,-10,nb1+10);
        glTexCoord2f(1-roll,1-roll);glVertex3i(-10,10,nb1+10);
        glTexCoord2f(0-roll,1-roll);glVertex3i(nb2+10,10,nb1+10);
        // gauche
        glTexCoord2f(0-roll,0-roll);glVertex3i(-10,-10,nb1+10);
        glTexCoord2f(1-roll,0-roll);glVertex3i(-10,-10,-10);
        glTexCoord2f(1-roll,1-roll);glVertex3i(-10,10,-10);
        glTexCoord2f(0-roll,1-roll);glVertex3i(-10,10,nb1+10);
        // haut
        glTexCoord2f(1-roll,0-roll);glVertex3i(-10,10,-10);
        glTexCoord2f(0-roll,0-roll);glVertex3i(nb2+10,10,-10);
        glTexCoord2f(0-roll,1-roll);glVertex3i(nb2+10,10,nb1+10);
        glTexCoord2f(1-roll,1-roll);glVertex3i(-10,10,nb1+10);
        // bas
        glTexCoord2f(0-roll,0-roll);glVertex3i(-10,-10,nb1+10);
        glTexCoord2f(1-roll,0-roll);glVertex3i(nb2+10,-10,nb1+10);
        glTexCoord2f(1-roll,1-roll);glVertex3i(nb2+10,-10,-10);
        glTexCoord2f(0-roll,1-roll);glVertex3i(-10,-10,-10);
    glEnd();
 }  // fin func
*/

//------------------------------------------------------------------------------
// Fin Du Fichier
//------------------------------------------------------------------------------

/*
    if (m3D)
     {

        // EXPLICATIONS
        //
        // devant -> X : où on est | 0 : trou | 1 : sol | 2 : sol effacé par l'algo
        // 
        // 11111    Comme il y a un 0, les 2 seront effacés car on cherche les nombres sur la ligne
        // 11111    qui possède un 0. On fait pareil pour toutes les autres directions.
        // X1022
        // 11111

        // devant
        for (y=int(run/scal+1)+1; y<=nb2; y++)
            if (mattmp[int(move_rl/scal+1)][y-1]==0) mattmp[int(move_rl/scal+1)][y]=0;

        // derrière
        for (y=int(run/scal+1)-1; y>=1; y--)
            if (mattmp[int(move_rl/scal+1)][y+1]==0) mattmp[int(move_rl/scal+1)][y]=0;

        // haut
        for (x=int(move_rl/scal+1)-1; x>=1; x--)
            if (mattmp[x+1][int(run/scal+1)]==0) mattmp[x][int(run/scal+1)]=0;

        // bas
        for (x=int(move_rl/scal+1)+1; x<=nb1; x++)
            if (mattmp[x-1][int(run/scal+1)]==0) mattmp[x][int(run/scal+1)]=0;

        // EXPLICATIONS
        //
        // coin haut droit -> X : où on est | 0 : trou | 1 : sol | 2 : sol effacé par l'algo
        // 
        // 11121    Comme il y a un 0, le 2 sera effacé car on cherche les nombres sur la diagonale
        // 11011    qui possède un 0. On fait pareil pour tous les coins possibles.
        // X1111
        // 11111

        // coin haut droit
        for (x=int(move_rl/scal+1)-2; x>=1; x--)
            for (y=int(run/scal+1)+2; y<=nb2; y++)
                if ((mattmp[x+1][y-1]==0) && ((mattmp[x+1][y]==0))) mattmp[x][y]=0;

        // coin bas droit
        for (x=int(move_rl/scal+1)+2; x<=nb1; x++)
            for (y=int(run/scal+1)+2; y<=nb2; y++)
                if ((mattmp[x-1][y-1]==0) && ((mattmp[x-1][y]==0))) mattmp[x][y]=0;

        // coin haut gauche
        for (x=int(move_rl/scal+1)-2; x>=1; x--)
            for (y=int(run/scal+1)-2; y>=1; y--)
                if ((mattmp[x+1][y+1]==0) && ((mattmp[x+1][y]==0))) mattmp[x][y]=0;

        // coin bas gauche
        for (x=int(move_rl/scal+1)+2; x<=nb1; x++)
            for (y=int(run/scal+1)-2; y>=1; y--)
                if ((mattmp[x-1][y+1]==0) && ((mattmp[x-1][y]==0))) mattmp[x][y]=0;

        // EXPLICATIONS
        //
        // angle droit haut droit -> X : où on est | 0 : trou | 1 : sol | 2 : sol effacé par l'algo
        // 
        // 11111    Comme il y a deux 0, ils forment un mur. Le 2 sera effacé.
        // 10211    On fait pareil pour tous les angles droits possibles.
        // X1011
        // 11111

        // angle droit haut droit
        for (x=int(move_rl/scal+1); x>=1; x--)
            for (y=int(run/scal+1); y<=nb2; y++)
                if ((mattmp[x][y]==0) && (mattmp[x-1][y-1]==0))
                    mattmp[x-1][y]=0;

        // angle droit bas droit
        for (x=int(move_rl/scal+1); x<=nb1; x++)
            for (y=int(run/scal+1); y<=nb2; y++)
                if ((mattmp[x][y]==0) && (mattmp[x+1][y-1]==0))
                    mattmp[x+1][y]=0;

        // angle droit haut gauche
        for (x=int(move_rl/scal+1); x>=1; x--)
            for (y=int(run/scal+1); y>=1; y--)
                if ((mattmp[x][y]==0) && (mattmp[x-1][y+1]==0))
                    mattmp[x-1][y]=0;

        // angle droit bas gauche
        for (x=int(move_rl/scal+1); x<=nb1; x++)
            for (y=int(run/scal+1); y>=1; y--)
                if ((mattmp[x][y]==0) && (mattmp[x+1][y+1]==0))
                    mattmp[x+1][y]=0;
    }
*/