Partage
  • Partager sur Facebook
  • Partager sur Twitter

pacman [c] + openGL avec fichier txt pour la map

Modification de la map après déplacement

    21 mai 2017 à 12:33:47

    Bonjour,

    Je me tourne vers vous car là, je galère complètement.

    Je réalise un pacman en [c]. J'ai comme contrainte obligatoire: L'utilsation d'OpenGL, Glut et un fichier txt pour initialiser la map. 

    Mon problème est que je n'arrive pas à modifier cette map après un déplacement de pacman. J'aimerais que les pastilles deviennent une case vide après la passage de pacman. Je vois bien ou se situe l'erreur (appel de la fonction "matrice() ) dans ma fonction vDisplay() mais je ne trouve pas la solution    : (

    Je dois rendre ce pacman Dimanche prochain avec un stade BEAUCOUP plus avancé!! Je commence vraiment à paniquer.

    Je vous poste mon code et le fichier .txt joins à ce code.

    J'ai aussi des problèmes avec la position de pacman et fantome. si vous avez une idée sur ce point aussi, n'hésitez pas.

    C'est la première fois que je demande de l'aide sur un forum, j'espère avoir respecter toutes les règles.

    D'avance merci

    #include <stdio.h>
    #include <stdlib.h>
    #include <GL/glut.h>
    #include <GL/gl.h>
    #include <GL/glu.h>
    
    
    
    //Constantes globales
    
    #define TAILLE_BLOC					20
    #define NB_BLOC_COLONNE			23
    #define NB_BLOC_LIGNE				22
    #define WIDTH								700
    #define HEIGHT							1000
    
    int **L;
    
    
    struct personnage
    {
    int posx;
    int posy;
    };
    struct personnage pac, fan1, fan2, fan3, fan4;
    
    struct personnage pac={.posx=12, .posy=11};
    struct personnage fan1={.posx=8, .posy=11};
    struct personnage fan2={.posx=10, .posy=9};
    struct personnage fan3={.posx=10, .posy=11};
    struct personnage fan4={.posx=10, .posy=13};
    
    
    
    //Déclaration de fonctions
    void dessinerRepere(unsigned int echelle);
    void dessinerMur(double cote,double cote2);
    void dessinerVide(double cote,double cote2);
    void dessinerPastille(double cote,double cote2);
    void dessinerSuperpastille(double cote,double cote2);
    void dessinerPacman(double cote,double cote2);
    void dessinerFantome1(double cote,double cote2);
    void dessinerFantome2(double cote,double cote2);
    void dessinerFantome3(double cote,double cote2);
    void dessinerFantome4(double cote,double cote2);
    
    void positionPacman();
    
    void vDisplay();
    void vTimerIdle(int i);
    void vSpecial(int key, int x, int y);
    
    
    
    int matrice(int N, int M)
    	{
    		char c;
    		int i = 0;
    		int j = 0;
    
    		L = malloc(N * sizeof(char*));
    		FILE *fichier = NULL;
    		fichier = fopen("Map1.txt", "r");
    
    		if(fichier == NULL)
    			{
    			printf("file empty");
    			return 0;
    			}
    
    		L[i] = malloc(M * sizeof(int));
    
    		while((c = fgetc(fichier)) != EOF)
    			{
    			if(c == '\n'){
    			i++;
    			j = 0;
    			L[i] = malloc(M * sizeof(int));
    			}
    
    		else
    			{
    			
    			if (c=='0') L[i][j] = 0;
    			else if (c=='1') L[i][j] = 1;
    			else if (c=='2') L[i][j] = 2;
    			else if (c=='3') L[i][j] = 3;
    			else if (c=='4') L[i][j] = 4;
    			else if (c=='5') L[i][j] = 5;
    			else if (c=='6') L[i][j] = 6;
    			else if (c=='7') L[i][j] = 7;
    			else if (c=='8') L[i][j] = 8;
    			j++;
    			}
    		}
    		fclose(fichier);
    	}
    
    
    
    
    
    //Mes fonctions "dessiner"
    
    void dessinerRepere(unsigned int echelle)
    {
        glPushMatrix();
        glScalef(echelle,echelle,echelle);
        glBegin(GL_LINES);
        glColor3ub(0,0,255);
        glVertex2i(0,0);
        glVertex2i(20,0);
        glColor3ub(0,255,0);
        glVertex2i(0,0);
        glVertex2i(0,20);
        glEnd();
        glPopMatrix();
    }
    
    
    //Fonction dessine MUR
    	void dessinerMur(double cote,double cote2)
    		{
    				glBegin(GL_QUADS);
    				glColor3ub(250,250,250);
    				glVertex2d(0,-cote/2);
    				glVertex2d(0,cote/2);
    				glVertex2d(cote,cote/2);
    				glVertex2d(cote,-cote/2);
    				glEnd();
    		}
    
    
    //Fonction dessine VIDE
    	void dessinerVide(double cote,double cote2)
    		{
    				glBegin(GL_QUADS);
    				glColor3ub(0,0,0);
    				glVertex2d(0,-cote/2);
    				glVertex2d(0,cote/2);
    				glVertex2d(cote,cote/2);
    				glVertex2d(cote,-cote/2);
    				glEnd();
    		}
    
    
    //Fonction dessine PASTILLE
    	void dessinerPastille(double cote,double cote2)
    		{
    				glBegin(GL_QUADS);
    				glColor3ub(253,182,11);
    				glVertex2d(0,-cote/2);
    				glVertex2d(0,cote/2);
    				glVertex2d(cote,cote/2);
    				glVertex2d(cote,-cote/2);
    				glEnd();
    		}
    
    //Fonction dessine SUPERPASTILLE
    	void dessinerSuperpastille(double cote,double cote2)
    		{
    				glBegin(GL_QUADS);
    				glColor3ub(253,11,239);
    				glVertex2d(0,-cote/2);
    				glVertex2d(0,cote/2);
    				glVertex2d(cote,cote/2);
    				glVertex2d(cote,-cote/2);
    				glEnd();
    		}
    
    //Fonction dessine PACMAN
    	void dessinerPacman(double cote,double cote2)
    		{
    				glBegin(GL_QUADS);
    				glColor3ub(253,244,11);
    				glVertex2d(0,-cote/2);
    				glVertex2d(0,cote/2);
    				glVertex2d(cote,cote/2);
    				glVertex2d(cote,-cote/2);
    				glEnd();
    		}
    
    //Fonction dessine FANTOME1
    	void dessinerFantome1(double cote,double cote2)
    		{
    
    				glBegin(GL_QUADS);
    				glColor3ub(253,0,11);
    				glVertex2d(0,-cote/2);
    				glVertex2d(0,cote/2);
    				glVertex2d(cote,cote/2);
    				glVertex2d(cote,-cote/2);
    				glEnd();
    		}
    
    //Fonction dessine FANTOME2
    	void dessinerFantome2(double cote,double cote2)
    		{
    
    				glBegin(GL_QUADS);
    				glColor3ub(0,244,11);
    				glVertex2d(0,-cote/2);
    				glVertex2d(0,cote/2);
    				glVertex2d(cote,cote/2);
    				glVertex2d(cote,-cote/2);
    				glEnd();
    		}
    
    //Fonction dessine FANTOME3
    	void dessinerFantome3(double cote,double cote2)
    		{
    
    				glBegin(GL_QUADS);
    				glColor3ub(253,110,0);
    				glVertex2d(0,-cote/2);
    				glVertex2d(0,cote/2);
    				glVertex2d(cote,cote/2);
    				glVertex2d(cote,-cote/2);
    				glEnd();
    		}
    
    //Fonction dessine FANTOME4
    	void dessinerFantome4(double cote,double cote2)
    		{
    
    				glBegin(GL_QUADS);
    				glColor3ub(100,144,11);
    				glVertex2d(0,-cote/2);
    				glVertex2d(0,cote/2);
    				glVertex2d(cote,cote/2);
    				glVertex2d(cote,-cote/2);
    				glEnd();
    		}
    
    
    
    
    //Dessine la map en parcourant le fichier matrice
    void vDisplay()
    {
    matrice(22,23); //A mon avis, le problème vient d'ici!! Il reprend tjs la matrice initiale
    
    int i=0;
    int j=0;
    
    glClear( GL_COLOR_BUFFER_BIT );
    
        glMatrixMode( GL_MODELVIEW );
        glLoadIdentity( );
    
        /* Je déplace mon répère initial (actuellement
        en bas à gauche de l'écran) */
        glTranslated(200,600,0);
    
    	for (i=0;i<NB_BLOC_LIGNE;i++)
    	{
    		for (j=0;j<NB_BLOC_COLONNE;j++)
    		{
    			
    
    			if(L[i][j]==0)
    				{
    				dessinerVide(TAILLE_BLOC,TAILLE_BLOC);
    				glTranslated(20,0,0);
    				}
    
    			else if(L[i][j]==1)
    				{				
    				dessinerMur(TAILLE_BLOC,TAILLE_BLOC);
    				glTranslated(20,0,0);
    				}
    
    			else if(L[i][j]==2)
    				{
    				dessinerPastille(TAILLE_BLOC,TAILLE_BLOC);
    				glTranslated(20,0,0);
    				}
    			
    			else if(L[i][j]==3)
    				{
    				dessinerSuperpastille(TAILLE_BLOC,TAILLE_BLOC);
    				glTranslated(20,0,0);
    				}
    
    			else if(L[i][j]==4)
    				{
    				dessinerPacman(TAILLE_BLOC,TAILLE_BLOC);
    				glTranslated(20,0,0);
    				}
    
    			else if(L[i][j]==5)
    				{
    				dessinerFantome1(TAILLE_BLOC,TAILLE_BLOC);
    				glTranslated(20,0,0);
    				}
    
    			else if(L[i][j]==6)
    				{
    				dessinerFantome2(TAILLE_BLOC,TAILLE_BLOC);
    				glTranslated(20,0,0);
    				}
    
    			else if(L[i][j]==7)
    				{
    				dessinerFantome3(TAILLE_BLOC,TAILLE_BLOC);
    				glTranslated(20,0,0);
    				}
    
    			else if(L[i][j]==8)
    				{
    				dessinerFantome4(TAILLE_BLOC,TAILLE_BLOC);
    				glTranslated(20,0,0);
    				}
    			positionPacman();
    			positionFan1();
    			positionFan2();
    			positionFan3();
    			positionFan4();
    			
    		}
    		glTranslated(-460,-20,0);
        //glFlush();
    	}
    		
    			
        glutSwapBuffers();	//Permutation des 2 buffers
    }
    
    
    
    //Permets le redimensionnement de la fenêtre
    void vReshape(int w, int h) 
    {
    	float L;
    	float H;
    	
    	glViewport(0,0,w,h);
    	glMatrixMode(GL_PROJECTION); // Choisit la matrice de projection
    	glLoadIdentity();
    	gluOrtho2D(0,HEIGHT,0,WIDTH);	
    }
    
    
    //Fonction position peronnages
    void positionPacman()
    {
    L[pac.posx][pac.posy]=4;
    }
    
    void positionFan1()
    {
    L[fan1.posx][fan1.posy]=5;
    }
    void positionFan2()
    {
    L[fan2.posx][fan2.posy]=6;
    }
    void positionFan3()
    {
    L[fan3.posx][fan3.posy]=7;
    }
    void positionFan4()
    {
    L[fan4.posx][fan4.posy]=8;
    }
    
    
    /*
    void deplacementPacman()
    {
    
    
    if (L[pac.posx-1][pac.posy]!=1)
    		{
    		L[pac.posx-1][pac.posy]=4;
    		L[pac.posx][pac.posy]=0;
    		pac.posx--;
    		}
    
    if (L[pac.posx+1][pac.posy]!=1)
    		{
    		L[pac.posx+1][pac.posy]=4;
    		L[pac.posx][pac.posy]=0;
    		pac.posx++;
    		}
    
    if (L[pac.posx][pac.posy-1]!=1)
    		{
    		L[pac.posx][pac.posy-1]=4;
    		L[pac.posx][pac.posy]=0;
    		pac.posy--;
    		}
    
    if (L[pac.posx][pac.posy+1]!=1)
    		{
    		L[pac.posx][pac.posy+1]=4;
    		L[pac.posx][pac.posy]=0;
    		pac.posy++;
    		}
    
    }
    */
    
    
    
    
    //Fonction Timer
    void vTimerIdle(int i)
    {
    	glutPostRedisplay();
    	glutTimerFunc(20,vTimerIdle,i);	// On choisit un timer de 20ms
    }
    
    
    
    
    //Gestion du clavier
    void vSpecial(int key, int x, int y)
    {
    
    	switch (key)
    	{
    
    
    		case GLUT_KEY_UP :
    
    			if (L[pac.posx-1][pac.posy]!=1)
    			{
    			L[pac.posx-1][pac.posy]=4;
    			L[pac.posx][pac.posy]=0;
    			pac.posx--;
    			}	
    			break;
    				
    
    		case GLUT_KEY_DOWN :
    
    			if (L[pac.posx+1][pac.posy]!=1)
    			{
    			L[pac.posx+1][pac.posy]=4;
    			L[pac.posx][pac.posy]=0;
    			pac.posx++;
    			}
    			break;
    
    		case GLUT_KEY_LEFT :
    
    			if (L[pac.posx][pac.posy-1]!=1)
    			{
    			L[pac.posx][pac.posy-1]=4;
    			L[pac.posx][pac.posy]=0;
    			pac.posy--;
    			}
    			break;
    
    		case GLUT_KEY_RIGHT :
    
    			if (L[pac.posx][pac.posy+1]!=1)
    			{
    			L[pac.posx][pac.posy+1]=4;
    			L[pac.posx][pac.posy]=0;
    			pac.posy++;
    			}
    			break;
    
    	}
    }
    
    
    
    
    int main( int argc, char *argv[ ])
    {
    
    
    	glutInit(&argc,argv);	// initialisation de GLUT : argc et argv sont respectivement
    												// le nombre et la liste des paramètres passées en ligne de commande
    	glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);	// GLUT_RGBA mode "vraies couleurs" 32 bits
    																								// GLUT_SINGLE "simple buffering" - un seul tampon
    																								// Modes par défaut
    		
    	glutInitWindowSize(HEIGHT,WIDTH);	// Initialisation de la largeur et de la hauteur de la fenêtre
    	glutInitWindowPosition(50,50);	// Position de la fenêtre sur l'écran par rapport au coin haut gauche
    	glutCreateWindow("pacman");	// Titre de la fenêtre
    	
    	glutDisplayFunc(vDisplay);
    	glutReshapeFunc(vReshape);
    	
    	glutSpecialFunc(vSpecial); // Gestion des touches spéciales du clavier
    	glutTimerFunc(20, vTimerIdle, 1); //20 ms
    
    	glutMainLoop(); // lance le gestionnaire glut
    	return 0;
    }
    


    Le fichier .txt:

    11111111111111111111111
    12222222222122222222221
    13111211112121111211131
    12111211112121111211121
    12222222222222222222221
    12111211211111211211121                               
    12222211222122211222221
    11111211112121111211111
    11111212222222221211111
    11111212111111121211111
    22222222100000122222222
    11111212111111121211111
    11111212000000021211111
    11111212111111121211111
    12222222222122222222221
    12111211112121111211121
    12211222222222222211221
    11211212111111121211211
    12222212222122221222221
    13111111112121111111131
    12222222222222222222221
    11111111111111111111111


    • Partager sur Facebook
    • Partager sur Twitter
      21 mai 2017 à 18:47:39

      Bonjour,

      matrice( NB_BLOC_LIGNE , NB_BLOC_COLONNE ); doit être appelée dans le main(), puis en effet il ne faut surtout plus l'appeler après.

      • Partager sur Facebook
      • Partager sur Twitter

      En recherche d'emploi.

        21 mai 2017 à 20:13:44

        Je te remercie, je vais travailler dans ce sens mais je ne vois pas comment l'appeler qu'un seul fois :/ J'ai essayé d'appeler la matrice sans passer par une fonction GLUT, ca me donne le même résultat. J'ai aussi essayé de copier mon tableau L[i][j] dans un autre tableau et de travailler sur ce deuxième tableau, idem. Ce soir et demain, j'essayerai avec des pointeurs et mettre des paramètres dans certaines fonctions mais là, je bloque complètement!!

        Ne suis-je pas mal parti dans la construction global du code?

        • Partager sur Facebook
        • Partager sur Twitter

        pacman [c] + openGL avec fichier txt pour la map

        × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
        × Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
        • Editeur
        • Markdown