//------------------------------------------------------------------------------
// 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;
}
*/