projet de Memory en C

Personnel/Dev/C/MEMORY/Makefile

@@ -0,0 +1,14 @@
+Memory.exe : main.o partie_graphique.o jeu.o cartes.o
+	gcc -o Memory.exe main.o partie_graphique.o jeu.o cartes.o -lgraph
+
+main.o : main.c cartes.h partie_graphique.h
+	gcc -c main.c -lgraph
+
+partie_graphique.o : partie_graphique.c partie_graphique.h jeu.h cartes.h
+	gcc -c partie_graphique.c -lgraph
+
+jeu.o : jeu.c jeu.h partie_graphique.h
+	gcc -c jeu.c -lgraph
+
+cartes.o : cartes.c cartes.h
+	gcc -c cartes.c -lgraph

Personnel/Dev/C/MEMORY/README.md

@@ -0,0 +1,2 @@
+# SAE1.1_DEV
+

Personnel/Dev/C/MEMORY/cartes.c

@@ -0,0 +1,54 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include "cartes.h"
+
+#define COTE_CARRE 150
+#define ECART 5
+#define MARGE 120
+
+/*associe chaque carte à un numéro de tableau*/
+void remplirCartes(int* cartes){
+  int i;
+  int j;
+  for (i=0, j=0 ;i<25;i++, j+=2){
+    cartes[j]=i;
+    cartes[j+1]=i;
+  }
+}
+
+/*associe des cartes aléatoires aux positions données*/
+void randomRemplir(int** positions, int colonnes, int lignes, int nbrCartes){
+  srand(time(NULL));
+  int i;
+  int j;
+  int k;
+  int* cartesUtilisees=(int*)malloc(sizeof(int));
+  int taille=0;
+  int sortie;
+  int valeur;
+  int egalite;
+  for (i=0; i<colonnes ; i++){
+    for (j=0; j<lignes; j++){
+      sortie=0;
+      while (sortie==0){
+	egalite=0;
+	valeur = rand() % nbrCartes;
+	for (k=0;k<taille;k++){
+	  if (cartesUtilisees[k] == valeur) {
+	    egalite = 1;
+	  }
+	}
+	if (egalite==0){
+	  positions [valeur][0]=i*(COTE_CARRE+ECART)+MARGE;
+	  positions [valeur][1]=j*(COTE_CARRE+ECART)+MARGE;
+	  sortie=1;
+	  cartesUtilisees[taille]=valeur;
+	  taille+=1;
+	  cartesUtilisees=realloc(cartesUtilisees,(taille+1)*sizeof(int));
+	}
+      }
+    }
+  }
+  free(cartesUtilisees);
+}

Personnel/Dev/C/MEMORY/cartes.h

@@ -0,0 +1,16 @@
+#ifndef CARTE_H
+#define CARTE_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+#define COTE_CARRE 150
+#define ECART 5
+#define MARGE 120
+
+
+void remplirCartes(int* cartes);
+void randomRemplir(int** positions, int colonnes, int lignes, int nbrCartes);
+
+#endif 

Personnel/Dev/C/MEMORY/jeu.c

@@ -0,0 +1,215 @@
+/* Ce programme sert au moment ou le joueur à passé l'interface et se met à jouer*/
+#include <stdlib.h>
+#include <stdio.h>
+#include <graph.h>
+#include "jeu.h"
+#include "partie_graphique.h"
+
+#define COTE_CARRE 150
+#define ECART 5
+#define MARGE 120
+
+
+/*retourne le numéro de la carte aux coordonnées cliquées*/
+void retournerCarte(int numCarte, int* cartes, int x, int y){
+  char nomCarte[25];
+  sprintf(nomCarte,"./images/image%d.png",cartes[numCarte]);
+  ChargerImage(nomCarte,x,y,0,0,COTE_CARRE,COTE_CARRE);
+}
+  
+/*cache la carte si on n'a pas retourné de paires*/
+  void cacherCarte(int carte,int** positions){
+    int x=positions[carte][0];
+    int y=positions[carte][1];
+    ChargerImage("./images/dos.png",x,y,10,75,COTE_CARRE,COTE_CARRE);
+}
+
+/*retourne 1 si il y a une paire, 0 sinon*/
+  int verifPaire(int carte1, int carte2, int* cartes){
+    int paire=0;
+    if (cartes[carte1]==cartes[carte2]){
+      paire=1;
+    }
+    return paire;
+  }
+
+/*joue*/
+void jeu( int** positions, int* cartes, int colonnes, int lignes){
+    int* carteRetournees = (int*)malloc(sizeof(int));
+    int x;
+    int y;
+    int nbrPaires=(colonnes*lignes)/2;
+    int boucle_jeu=1;
+    int boucle_victoire;
+    int dejaRetournee=0;
+    int nbrCartesRetournees=0;
+    int numCarte[2]; //  tableau des deux cartes retournées 
+    numCarte[0]=-1;
+    numCarte[1]=-2;
+    int nbrCartes=0;
+    int XpositionCarte;
+    int YpositionCarte;
+    unsigned long temps_ecoule = 0;
+    unsigned long temps = Microsecondes();
+    int timer;
+    int seconde_passee;
+    int minutes = 0;
+    int secondes = 0;
+    int toucheT = 0;
+    int temps_reference = 0;
+    char afficher_temps[20];
+    int temps_cartes_visibles;
+    int i;
+    int j;
+    int k;
+    int l;
+    
+      
+    while ((nbrPaires > 0)&&(boucle_jeu==1)){ //boucle while principale
+
+       temps_ecoule = (int) (Microsecondes() - temps); /*timer*/
+       if (temps_reference<temps_ecoule){
+	temps_reference += 1;
+	timer = (int) (temps_ecoule / 1000000);
+	if (timer != seconde_passee){
+	  seconde_passee = timer;
+	  secondes = timer;
+	  if (secondes > 59){
+	    minutes = secondes / 60;
+	    secondes = secondes - (minutes * 60);
+	  }
+	  ChoisirCouleurDessin(CouleurParNom("white"));
+	  RemplirRectangle(1000,25,130,30);
+	  ChoisirCouleurDessin(CouleurParNom("black"));
+	  snprintf(afficher_temps,20,"Time : %02d : %02d", minutes, secondes);
+	  EcrireTexte(1000,50,afficher_temps,1);
+	}
+      }
+       
+       if (ToucheEnAttente()){ //mode tricheurs
+	if (Touche()== XK_t){
+	  toucheT = 1;
+	  while (toucheT == 1){
+	    /*montrer les cartes*/
+	    for (i=0; i<(colonnes*lignes); i++){
+	      retournerCarte(i, cartes, positions[i][0], positions[i][1]);
+	    }
+	      
+	    if (ToucheEnAttente()){
+	      if (Touche()== XK_t){
+		/*cacher les cartes pas encore trouvées*/
+		afficherCartes(colonnes, lignes, positions);
+		for (i=0;i<nbrCartesRetournees;i++){
+		  retournerCarte(carteRetournees[i],cartes,positions[carteRetournees[i]][0], positions[carteRetournees[i]][1]);
+		}
+		toucheT = 0;
+		temps = Microsecondes() - temps_ecoule;
+	      }
+	    }
+	  }
+	}
+      }
+      	
+       if(SourisCliquee()){ //jeu 
+	SourisPosition();/*récupère l'endroit du clic de la souris*/
+	x=_X;
+	y=_Y;
+	if (x>1430 && x<1550 && y>20 && y<60){
+	  boucle_jeu=quitter(boucle_jeu);
+	}
+	
+	else{ 
+	  for (i=0;i<colonnes;i++){ /*pour chaque colonne*/
+	    for (j=0;j<lignes;j++){ /*et chaque ligne :*/
+	      dejaRetournee=0;	
+	      XpositionCarte=i*(COTE_CARRE+ECART)+120;
+	      YpositionCarte=j*(COTE_CARRE+ECART)+120;
+	      if ( (XpositionCarte <= x)&&(x <= (XpositionCarte+150))&&(YpositionCarte <= y)&&(y <= (YpositionCarte+150))){ /*regarde si la position cliquée correspond à une position de carte*/
+		for (k=0;k<(colonnes*lignes);k++){ 
+		  if ((positions[k][0]==XpositionCarte)&&(positions[k][1]==YpositionCarte)){/*retrouve la carte correspondant aux coordonnées trouvées*/
+
+		    
+		    for (l=0;l<nbrCartesRetournees;l++){/*verifie que la carte n'a pas déja été retournée*/
+		      if (carteRetournees[l]==k){
+			dejaRetournee=1;
+		      }
+		    }
+		    
+		    if (dejaRetournee==0){ /*si la carte n'a pas deja été retournée, le programme continue. sinon, rien ne se passe*/
+		      numCarte[nbrCartes]=k;
+		      if(numCarte[0]!=numCarte[1]){		
+			numCarte[nbrCartes]=k;
+			retournerCarte(k, cartes, positions[k][0], positions[k][1]);
+			nbrCartes+=1;
+		      
+			if (nbrCartes==2){ /*si les deux cartes ont été retournées :*/
+			  if(verifPaire(numCarte[0],numCarte[1],cartes)==1){ //si les deux cartes sont des paires, elles restent retournées
+			    nbrPaires-=1; //et le nombre de paires diminuent 
+			    carteRetournees[nbrCartesRetournees]=numCarte[0];
+			    nbrCartesRetournees+=1;
+			    carteRetournees = realloc(carteRetournees,(nbrCartesRetournees+1)*sizeof(int));
+			    carteRetournees[nbrCartesRetournees]=numCarte[1];
+			    nbrCartesRetournees+=1;
+			    carteRetournees = realloc(carteRetournees,(nbrCartesRetournees+1)*sizeof(int));
+			  }
+			  else{ //sinon, après 2 secondes les cartes se retournent 
+			    temps_cartes_visibles = timer + 2;
+			    while(temps_cartes_visibles > timer){
+			      temps_ecoule = (int) (Microsecondes() - temps);
+			      if (temps_reference<temps_ecoule){
+				temps_reference += 1;
+				timer = (int) (temps_ecoule / 1000000);
+				if (timer != seconde_passee){
+				  seconde_passee = timer;
+				  secondes = timer;
+				  if (secondes > 59){
+				    minutes = secondes / 60;
+				    secondes = secondes - (minutes * 60);
+				  }
+				  ChoisirCouleurDessin(CouleurParNom("white"));
+				  RemplirRectangle(1050,25,100,30);
+				  ChoisirCouleurDessin(CouleurParNom("black"));
+				  snprintf(afficher_temps,20,"Time : %02d : %02d", minutes, secondes);
+				  EcrireTexte(1000,50,afficher_temps,1);
+				}
+			      }
+			    }
+			    cacherCarte(numCarte[0],positions);
+			    cacherCarte(numCarte[1],positions);
+			  }
+			  nbrCartes=0;
+			  numCarte[0]=-1;
+			  numCarte[1]=-2;
+			}
+		      }	    
+		    }
+		  }
+		}
+	      }
+	    }
+	  }
+	}
+      }
+    }
+    if (nbrPaires == 0){
+      boucle_victoire = 1;
+      ChargerImageFond("./images/fond.jpg");
+      ChoisirCouleurDessin(CouleurParNom("white"));
+      EcrireTexte(750,200,"BRAVO !!",2);
+      snprintf(afficher_temps,20,"Time : %02d : %02d", minutes, secondes);
+      EcrireTexte(750,300,afficher_temps,2);
+      DessinerRectangle(750,400,250,60);
+      EcrireTexte(765,445,"Retour menu",2);
+      while( boucle_victoire == 1){
+	if(SourisCliquee()){
+	  SourisPosition();/*récupère l'endroit du clic de la souris*/
+	  x=_X;
+	  y=_Y;
+	  if (x>750 && x<1000 && y>400 && y<460){
+	    boucle_victoire=quitter(boucle_victoire);
+	  }
+	}
+      }
+    }
+    free(carteRetournees);
+}

Personnel/Dev/C/MEMORY/jeu.h

@@ -0,0 +1,18 @@
+#ifndef JEU_H
+#define JEU_H
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <graph.h>
+
+#define COTE_CARRE 150
+#define ECART 5
+#define MARGE 120
+
+void retournerCarte(int numCarte, int* cartes, int x, int y);
+void cacherCarte(int carte, int** positions);
+int verifPaire(int carte1, int carte2, int* cartes);
+void jeu(int** positions, int* cartes, int colonnes, int lignes);
+
+
+#endif

Personnel/Dev/C/MEMORY/main.c

@@ -0,0 +1,18 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <graph.h>
+#include "partie_graphique.h"
+#include "cartes.h"
+
+int main (void){ //petite fonction qui se contente de définir les principales variable et d'appeler les fonctions principale
+  int i;
+  int cartes[50];//cartes va servir à associer chaque carte à un numéro
+  int** positions = (int**) malloc(50*sizeof(int*));// position associe chaque numéro à des coordonnées 
+  for (i=0;i<50;i++){
+    positions[i] = (int*) malloc(2*sizeof(int));
+  }
+  remplirCartes(cartes); 
+  partieGraphique(cartes,positions);
+  free(positions);
+  return EXIT_SUCCESS; 
+}

Personnel/Dev/C/MEMORY/partie_graphique.c

@@ -0,0 +1,140 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <graph.h>
+#include "partie_graphique.h"
+#include "jeu.h"
+#include "cartes.h"
+
+#define COTE_CARRE 150
+#define ECART 5
+#define MARGE 120
+
+int quitter(int boucle_jeu){ //retourne à l'écran d'accueil
+  boucle_jeu = 0;
+  ChargerImageFond("./images/fond.jpg");
+  ChoisirCouleurDessin(CouleurParNom("white"));
+  EcrireTexte(300,200,"JEU DES PAIRES",2);
+  EcrireTexte(300,215,"-------------------------",2);
+  EcrireTexte(300,350,"- Niveau demo",2);
+  EcrireTexte(300,450,"- Niveau facile",2);
+  EcrireTexte(300,550,"- Niveau moyen",2);
+  EcrireTexte(300,650,"- Niveau difficile",2);
+  DessinerRectangle(1470,20,120,40);
+  EcrireTexte(1470,50,"Quitter le jeu",1);
+  return boucle_jeu;
+}
+
+void afficherCartes(int colonnes, int lignes, int** positions){ // affiche toutes les cartes de dos selon le niveau de difficulté
+  int i;
+  int j;
+  for(i=MARGE; i<(colonnes*(COTE_CARRE+ECART)+MARGE); i+=COTE_CARRE+ECART){
+    for(j=MARGE ; j<(lignes*(COTE_CARRE+ECART)+MARGE) ; j+=COTE_CARRE+ECART){
+      ChargerImage("./images/dos.png",i,j,10,75,COTE_CARRE,COTE_CARRE);
+    }
+  }
+}
+
+void mode_demo(int** positions, int* cartes){
+  /*lancer le jeu en mode démo*/
+  int colonnes=2;
+  int lignes=2;
+  ChargerImageFond("./images/fond.jpg");
+  DessinerRectangle(1430,20,160,40);
+  EcrireTexte(1435,50,"Revenir au menu",1);
+  EcrireTexte(50,75,"Niveau demo",2);
+  afficherCartes(colonnes,lignes,positions);
+  randomRemplir(positions,colonnes,lignes,colonnes*lignes);
+  jeu(positions,cartes,colonnes,lignes);
+    
+}
+
+void mode_facile(int** positions, int* cartes){
+  /*lancer le jeu en mode facile*/
+  int colonnes=4;
+  int lignes=3;
+  ChargerImageFond("./images/fond.jpg");
+  DessinerRectangle(1430,20,160,40);
+  EcrireTexte(1435,50,"Revenir au menu",1);
+  EcrireTexte(50,75,"Niveau facile",2);
+  afficherCartes(colonnes,lignes,positions);
+  randomRemplir(positions,colonnes,lignes,colonnes*lignes);
+  jeu(positions,cartes,colonnes,lignes);
+}
+
+void mode_moyen(int** positions, int* cartes){
+  /*lancer le jeu en mode moyen*/
+  int colonnes=6;
+  int lignes=5;
+  ChargerImageFond("./images/fond.jpg");
+  DessinerRectangle(1430,20,160,40);
+  EcrireTexte(1435,50,"Revenir au menu",1);
+  EcrireTexte(50,75,"Niveau moyen",2);
+  afficherCartes(colonnes,lignes,positions);
+  randomRemplir(positions,colonnes,lignes,colonnes*lignes);
+  jeu(positions,cartes,colonnes,lignes);
+}
+
+void mode_difficile(int** positions, int* cartes){
+  /*lancer le jeu en mode difficile*/
+  int colonnes=10;
+  int lignes=5;
+  ChargerImageFond("./images/fond.jpg");
+  DessinerRectangle(1430,20,160,40);
+  EcrireTexte(1435,50,"Revenir au menu",1);
+  EcrireTexte(50,75,"Niveau difficile",2);
+  afficherCartes(colonnes,lignes,positions);
+  randomRemplir(positions,colonnes,lignes,colonnes*lignes);
+  jeu(positions,cartes,colonnes,lignes);
+  }
+
+
+
+void partieGraphique(int* cartes, int** positions){ /*fonction affichage du menu*/
+    int x;
+    int y;
+    int boucle_menu = 1 ;
+    InitialiserGraphique();
+    CreerFenetre(10,10,1920,1080);
+    
+    ChargerImageFond("./images/fond.jpg");
+    ChoisirCouleurDessin(CouleurParNom("white"));
+    EcrireTexte(300,200,"JEU DES PAIRES",2);
+    EcrireTexte(300,215,"-------------------------",2);
+    EcrireTexte(300,350,"- Niveau demo",2);
+    EcrireTexte(300,450,"- Niveau facile",2);
+    EcrireTexte(300,550,"- Niveau moyen",2);
+    EcrireTexte(300,650,"- Niveau difficile",2);
+    DessinerRectangle(1470,20,120,40);
+    EcrireTexte(1470,50,"Quitter le jeu",1);
+    
+    while (boucle_menu == 1){
+      if(SourisCliquee()){
+	SourisPosition();/*récupère l'endroit où passe la souris*/
+	 x=_X;
+	 y=_Y;
+	if (x>1470 && x<1590 && y>20 && y<60){
+	boucle_menu = 0;
+	}
+	if (x>300 && x<600){
+	  if (y>300 && y<350){
+	    /*lancer le jeu en mode démo*/
+	    mode_demo(positions,cartes);
+	  }
+	  if (y>400 && y<450){
+	    /*lancer le jeu en mode facile*/
+	    mode_facile(positions,cartes);
+	  }
+	  if (y>500 && y<550){
+	    /*lancer le jeu en mode moyen*/
+	    mode_moyen(positions,cartes);
+	  }
+	  if (y>600 && y<650){
+	    /*lancer le jeu en mode difficile*/
+	    mode_difficile(positions,cartes);
+	  }
+	}
+      }
+    }
+    FermerGraphique();
+}
+

Personnel/Dev/C/MEMORY/partie_graphique.h

@@ -0,0 +1,20 @@
+#ifndef PARTIE_GRAPHIQUE
+#define PARTIE_GRAPHIQUE
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <graph.h>
+
+#define COTE_CARRE 150
+#define ECART 5
+#define MARGE 120
+
+int quitter(int boucle_jeu);
+void afficherCartes(int colonnes, int lignes, int** positions);
+void mode_demo(int** positions, int* cartes);
+void mode_facile(int** positions, int* cartes);
+void mode_moyen(int** positions, int* cartes);
+void mode_difficile(int** positions, int* cartes);
+void partieGraphique(int* cartes, int** positions);
+
+#endif