Entrainements + fin TP structures

DEV1.1/Entrainements/test.c

@@ -0,0 +1,54 @@
+# include <stdio.h>
+# include <stdlib.h>
+# include <string.h>
+
+int compte_negatifs(int* t, int taille_t) {
+	if (taille_t == 1) {
+		return (t[taille_t-1] < 0);
+	}
+	return (t[taille_t-1] < 0) + compte_negatifs(t, taille_t-1);
+}
+
+void afficher_chaine(char* chaine, size_t taille_chaine) {
+	if (taille_chaine == 0) {
+		putchar(chaine[strlen(chaine)]);
+		putchar('\n');
+	}
+	else {
+		putchar(chaine[(strlen(chaine) - taille_chaine)]);
+		afficher_chaine(chaine, taille_chaine-1);
+	}
+}
+
+void afficher_chaine_reverse(char* chaine, size_t taille_chaine) {
+	if (taille_chaine == 1) {
+		putchar(chaine[0]);
+		putchar('\n');
+	}
+	else {
+		putchar(chaine[taille_chaine-1]);
+		afficher_chaine_reverse(chaine, taille_chaine-1);
+	}
+}
+
+int conversion_base_2(int entier) {
+	if (entier == 1) {
+		return 1;
+	}
+	if (entier == 2) {
+		return 0;
+	}
+	return (int)strcat((entier % 2 + '0'), ((char) conversion_base_2(entier/2)));
+
+}
+
+
+int main(void) {
+	/* int t[10] = {3, 2, 12,8, -29, 7, 34, 9, 10};
+	printf("%d\n",compte_negatifs(t, 10)); */
+	char* texte = "Go ecrire un roman juste pour voir si une fonction elle marche";
+	afficher_chaine(texte, strlen(texte));
+	afficher_chaine_reverse(texte, strlen(texte));
+	printf("%d\n", conversion_base_2(12));
+	return EXIT_SUCCESS;
+}

DEV1.1/SAé/Makefile

@@ -0,0 +1,11 @@
+jeu : menu_principal_v3.o jeu_principal_v3.o menu_de_fin_v3.o
+	gcc -ansi -pedantic -o jeu menu_principal_v3.o jeu_principal_v3.o menu_de_fin_v3.o -lgraph
+
+menu_principal_v3.o : menu_principal_v3.c 
+	gcc -ansi -pedantic -c menu_principal_v3.c 
+
+jeu_principal_v3.o : jeu_principal_v3.c 
+	gcc -ansi -pedantic -c jeu_principal_v3.c -lgraph 
+
+menu_de_fin_v3.o : menu_de_fin_v3.c 
+	gcc -ansi -pedantic -c menu_de_fin_v3.c 

DEV1.1/SAé/jeu_principal.c

@@ -0,0 +1,264 @@
+# include <stdio.h>
+# include <stdlib.h>
+# include <graph.h>
+
+void dessine_grille(int taille_grille) {
+	int i;
+	int j;
+	int cote_par_carre = (400/taille_grille);
+	for (i = 0; i != taille_grille; i++) {
+		for (j = 0; j != taille_grille; j++) {
+			ChoisirCouleurDessin(CouleurParNom("black"));
+			DessinerRectangle(50 + (cote_par_carre*i), 50 + (cote_par_carre*j), cote_par_carre, cote_par_carre);
+		}
+	}
+}
+
+int compte_nb_cases_occupees(int grille[9][9], int taille_grille) {
+	/* Renvoie le nombre de cases occupées (non vides) */
+	int compteur = 0;
+	int i,j;
+	for (i = 0; i != taille_grille; i++) {
+		for (j = 0; j != taille_grille; j++) {
+			if (grille[i][j] != 0) {
+				compteur++;
+			}
+		}
+	}
+	return compteur;
+}
+
+void initialise_grille(int grille[9][9], int taille_grille) {
+	int i;
+	int j;
+
+	for(i = 0; i != taille_grille; i++) {
+		for(j = 0; j != taille_grille; j++) {
+			grille[i][j] = 0;
+		}
+	}
+}
+
+int choisir_emplacement_pion(int joueur, int grille[9][9], int taille_grille) {
+	/* J1 : Rouge J2 : Bleu */
+	/* Renvoie 1 si le joueur a cliqué sur une case ou non */
+	couleur c;
+	int i,j;
+	int cote_par_carre = (400/taille_grille);
+	if (joueur == 1) {
+		c = CouleurParNom("dark red");
+		printf("Red");
+	}
+	else {
+		c = CouleurParNom("dark blue");
+		printf("Blue");
+	}
+	for (i = 0; i != taille_grille; i++) {
+		for (j = 0; j != taille_grille; j++) {
+			if (souris_clique_bouton(50 + (cote_par_carre*i), 50 + (cote_par_carre*j), cote_par_carre, cote_par_carre) && grille[i][j] == 0) {
+				ChoisirCouleurDessin(c);
+				DessinerArc(50 + (cote_par_carre*i), 50 + (cote_par_carre*j), cote_par_carre, cote_par_carre,360,360);
+				RemplirArc(50 + (cote_par_carre*i), 50 + (cote_par_carre*j), cote_par_carre, cote_par_carre,360,360);
+				dessine_grille(taille_grille);
+				grille[i][j] = joueur;
+				return 1;
+			}
+		}
+	}
+	return 0;
+}
+
+int choisir_emplacement_croix(int joueur, int grille[9][9], int taille_grille) {
+	/* J1 : Rouge J2 : Bleu */
+	/* Renvoie 1 si le joueur a cliqué sur une case ou non */
+	couleur c;
+	int i,j;
+	int cote_par_carre = (400/taille_grille);
+	if (joueur == 1) {
+		c = CouleurParNom("dark red");
+		printf("Red");
+	}
+	else {
+		c = CouleurParNom("dark blue");
+		printf("Blue");
+	}
+	for (i = 0; i != taille_grille; i++) {
+		for (j = 0; j != taille_grille; j++) {
+			if (souris_clique_bouton(50 + (cote_par_carre*i), 50 + (cote_par_carre*j), cote_par_carre, cote_par_carre) && grille[i][j] == 0) {
+				ChoisirCouleurDessin(c);
+				RemplirRectangle(50 + (cote_par_carre*i), 50 + (cote_par_carre*j), cote_par_carre, cote_par_carre);
+				dessine_grille(taille_grille);
+				grille[i][j] = 3;
+				return 1;
+			}
+		}
+	}
+	return 0;
+}
+
+int deplacement_valide(int joueur, int pos_deplacement_x, int pos_deplacement_y, int grille[9][9], int taille_grille) {
+	/* Renvoie 1 si le déplacement est valide, 0 sinon. */
+	int i,j;
+	int pos_joueur_x, pos_joueur_y;
+
+	for (i = 0; i != taille_grille; i++) {
+		for (j = 0; j != taille_grille; j++) {
+			if (grille[i][j] == joueur) {
+				pos_joueur_x = i;
+				pos_joueur_y = j;
+			}
+		}
+	}
+
+	/* Cas des 6 cases au dessus et en dessous du joueur */
+	for (i = (pos_joueur_x-1); i != (pos_joueur_x+2); i++) {
+		if (pos_deplacement_x == i 
+			&& (pos_deplacement_y == pos_joueur_y-1 || pos_deplacement_y == pos_joueur_y+1)
+		 	&& grille[pos_deplacement_x][pos_deplacement_y] == 0) {
+			printf("TEST");
+			return 1;
+		}
+	}
+	/* Cas des 2 cases à gauche et à droite du joueur */
+	if ((pos_deplacement_x == pos_joueur_x-1 || pos_deplacement_x == pos_joueur_x+1)
+		&& pos_deplacement_y == pos_joueur_y
+		&& grille[pos_deplacement_x][pos_deplacement_y] == 0) {
+		return 1;
+	}
+	return 0;
+
+}
+
+int deplacer_pion(int joueur, int grille[9][9], int taille_grille) {
+	/* Renvoie 1 si le déplacement s'est bien effectué, 0 sinon */
+	int i,j;
+	int cote_par_carre = (400/taille_grille);
+	int pos_deplacement_x, pos_deplacement_y;
+	int pos_joueur_x, pos_joueur_y;
+
+	for (i = 0; i != taille_grille; i++) {
+		for (j = 0; j != taille_grille; j++) {
+			if (souris_clique_bouton(50 + (cote_par_carre*i), 50 + (cote_par_carre*j), cote_par_carre, cote_par_carre)) {
+				pos_deplacement_x = i;
+				pos_deplacement_y = j;
+			}
+		}
+	}
+
+	for (i = 0; i != taille_grille; i++) {
+		for (j = 0; j != taille_grille; j++) {
+			if (grille[i][j] == joueur) {
+				pos_joueur_x = i;
+				pos_joueur_y = j;
+			}
+		}
+	}
+
+	if (deplacement_valide(joueur, pos_deplacement_x, pos_deplacement_y, grille, taille_grille)) {
+		int cote_par_carre = 400/taille_grille;
+		couleur c;
+		grille[pos_deplacement_x][pos_deplacement_y] = joueur;
+		grille[pos_joueur_x][pos_joueur_y] = 0;
+		if (joueur == 1) {
+			c = CouleurParNom("dark red");
+			printf("Red");
+		}
+		else {
+			c = CouleurParNom("dark blue");
+			printf("Blue");
+		}
+		ChoisirCouleurDessin(c);
+		DessinerArc(50 + (cote_par_carre*pos_deplacement_x), 50 + (cote_par_carre*pos_deplacement_y), cote_par_carre, cote_par_carre,360,360);
+		RemplirArc(50 + (cote_par_carre*pos_deplacement_x), 50 + (cote_par_carre*pos_deplacement_y), cote_par_carre, cote_par_carre,360,360);
+		ChoisirCouleurDessin(CouleurParNom("white"));
+		RemplirRectangle(50 + (cote_par_carre*pos_joueur_x), 50 + (cote_par_carre*pos_joueur_y), cote_par_carre, cote_par_carre);
+		dessine_grille(taille_grille);
+		return 1;
+	}
+	return 0;
+}
+
+
+int partie_a_deux_joueurs(int taille_grille) {
+	int joueur = 1;
+	int grille[9][9];
+	unsigned long cycle = 10000L;
+	unsigned long suivant = Microsecondes() + cycle;
+	int deplacement_fini = 0;
+	InitialiserGraphique();
+	CreerFenetre(100,100,500,500);
+	initialise_grille(grille, taille_grille);
+	dessine_grille(taille_grille);
+
+	/* Phase de placement des pions */
+	while (compte_nb_cases_occupees(grille, taille_grille) < 2) {
+		if (Microsecondes() > suivant) {
+			suivant = Microsecondes() + cycle;
+			if (joueur == 1) {
+
+				ChoisirCouleurDessin(CouleurParNom("dark red"));
+				EcrireTexte(250-(TailleChaineEcran("Tour du Joueur 1",1)/2), 475, "Tour du Joueur 1", 1);
+			}
+			else {
+				ChoisirCouleurDessin(CouleurParNom("white"));
+				RemplirRectangle(0,460,500,25);
+				ChoisirCouleurDessin(CouleurParNom("dark blue"));
+				EcrireTexte(250-(TailleChaineEcran("Tour du Joueur 2",1)/2), 475, "Tour du Joueur 2", 1);
+			}
+			if (SourisCliquee()) {
+				int nb_cases = compte_nb_cases_occupees(grille, taille_grille);
+				choisir_emplacement_pion(joueur, grille, taille_grille);
+				/* Permet d'éviter de passer au joueur suivant si on clique sur une case non vide */
+				if (nb_cases != compte_nb_cases_occupees(grille, taille_grille)) {
+					if (joueur == 1) {
+						joueur = 2;
+					}
+					else {
+						joueur = 1;
+					}
+				}
+				ChoisirCouleurDessin(CouleurParNom("white"));
+				RemplirRectangle(0,460,500,25);
+			}
+		}
+	}
+
+	/* Alterne les tours jusqu'à ce que la grille soit remplie */
+	while (compte_nb_cases_occupees(grille, taille_grille) < taille_grille*taille_grille) {
+		if (Microsecondes() > suivant) {
+			suivant = Microsecondes() + cycle;
+			if (joueur == 1) {
+
+				ChoisirCouleurDessin(CouleurParNom("dark red"));
+				EcrireTexte(250-(TailleChaineEcran("Tour du Joueur 1",1)/2), 475, "Tour du Joueur 1", 1);
+			}
+			else {
+				ChoisirCouleurDessin(CouleurParNom("white"));
+				RemplirRectangle(0,460,500,25);
+				ChoisirCouleurDessin(CouleurParNom("dark blue"));
+				EcrireTexte(250-(TailleChaineEcran("Tour du Joueur 2",1)/2), 475, "Tour du Joueur 2", 1);
+			}
+			if (SourisCliquee()) {
+				int nb_cases = compte_nb_cases_occupees(grille, taille_grille);
+				if (!deplacement_fini) {
+					deplacement_fini = deplacer_pion(joueur, grille, taille_grille);
+				}
+				else {
+					choisir_emplacement_croix(joueur, grille, taille_grille); 
+					/* Permet d'éviter de passer au joueur suivant si on clique sur une case non vide */
+					if (nb_cases != compte_nb_cases_occupees(grille, taille_grille)) {
+						if (joueur == 1) {
+							joueur = 2;
+						}
+						else {
+							joueur = 1;
+						}
+						deplacement_fini = 0;
+					}
+				}
+				ChoisirCouleurDessin(CouleurParNom("white"));
+				RemplirRectangle(0,460,500,25);
+			}
+		}
+	}
+}

DEV1.1/SAé/menu_principal.c

@@ -0,0 +1,72 @@
+# include <stdio.h>
+# include <stdlib.h>
+# include <graph.h>
+
+
+void affiche_boutons(void) {
+	/* Initialise le graphique et le ferme SEULEMENT si l'utilisateur ferme la 
+	fenêtre ou appuie sur QUITTER */
+	couleur c;
+	InitialiserGraphique();
+	CreerFenetre(100,100,500,500);
+	c = CouleurParNom("white");
+	EffacerEcran(c);
+	DessinerRectangle(150,300,200,50);
+	DessinerRectangle(150,375,200,50);
+	c = CouleurParNom("blue");
+	ChoisirCouleurDessin(c);
+	EcrireTexte(188,412, "QUITTER", 2);
+	c = CouleurParNom("red");
+	ChoisirCouleurDessin(c);
+	EcrireTexte(200,337, "JOUER", 2);
+	/* printf("\n%d\n", TailleChaineEcran("QUITTER", 2)); */
+}
+
+int souris_clique_bouton(int bouton_x, int bouton_y, int largeur, int hauteur) {
+	/* Prend en argument les coordonnées x et y du point en haut
+	à gauche du bouton, sa largeur et sa hauteur puis renvoie un booléen si 
+	la souris clique dans la zone du bouton (0 si oui, 1 sinon) */
+	int hitbox_largeur[500];
+	int hitbox_hauteur[500];
+	int i;
+	int j;
+	SourisCliquee();
+
+	/* Remplit le tableau hitbox_largeur avec toutes les coordonnées x qui correspondent
+	à celles du bouton */
+	for (i = 0; i != largeur; i++) {
+		hitbox_largeur[i] = i + bouton_x;
+	}
+
+	/* Remplit le tableau hitbox_hauteur avec toutes les coordonnées y qui correspondent
+	à celles du bouton */
+	for (i = 0; i != hauteur; i++) {
+		hitbox_hauteur[i] = i + bouton_y;
+	}
+
+	/* Vérifie si les coordonnées de la souris sont présentes dans les tableaux
+	qui définissent la hitbox du bouton */
+	for (i = 0; i != largeur; i++) {
+		for (j = 0; j != hauteur; j++) {
+			if ((hitbox_largeur[i] == _X) && (hitbox_hauteur[j] == _Y)) {
+				return 1;
+			}
+		}
+	}
+	return 0;
+}
+
+
+int main(void) {
+	int test = 1;
+	affiche_boutons();
+	while (1) {
+		if (souris_clique_bouton(150,375,200,50)) { 
+			FermerGraphique();
+			return EXIT_SUCCESS;
+		}
+		if (souris_clique_bouton(150,375,200,50)) {
+			/* Lancer le code du jeu */
+		}
+	} 
+}

DEV1.1/SAé/menu_principal_v1.c

@@ -0,0 +1,137 @@
+# include <stdio.h>
+# include <stdlib.h>
+# include <graph.h>
+
+
+void affiche_boutons(void) {
+	/* Initialise le graphique et le ferme SEULEMENT si l'utilisateur ferme la 
+	fenêtre ou appuie sur QUITTER */
+	couleur c;
+	c = CouleurParNom("white");
+	EffacerEcran(c);
+	c = CouleurParNom("black");
+	ChoisirCouleurDessin(c);
+	DessinerRectangle(150,300,200,50);
+	DessinerRectangle(150,375,200,50);
+	c = CouleurParComposante(0, 129, 60);
+	ChoisirCouleurDessin(c);
+	EcrireTexte(188,412, "QUITTER", 2);
+	c = CouleurParNom("dark blue");
+	ChoisirCouleurDessin(c);
+	EcrireTexte(200,337, "JOUER", 2);
+	/* printf("\n%d\n", TailleChaineEcran("QUITTER", 2)); */
+}
+
+int souris_clique_bouton(int bouton_x, int bouton_y, int largeur, int hauteur) {
+	/* Prend en argument les coordonnées x et y du point en haut
+	à gauche du bouton, sa largeur et sa hauteur puis renvoie un booléen si 
+	la souris clique dans la zone du bouton (0 si oui, 1 sinon) */
+	int hitbox_largeur[500];
+	int hitbox_hauteur[500];
+	int i;
+	int j;
+	SourisCliquee();
+
+	/* Remplit le tableau hitbox_largeur avec toutes les coordonnées x qui correspondent
+	à celles du bouton */
+	for (i = 0; i != largeur; i++) {
+		hitbox_largeur[i] = i + bouton_x;
+	}
+
+	/* Remplit le tableau hitbox_hauteur avec toutes les coordonnées y qui correspondent
+	à celles du bouton */
+	for (i = 0; i != hauteur; i++) {
+		hitbox_hauteur[i] = i + bouton_y;
+	}
+
+	/* Vérifie si les coordonnées de la souris sont présentes dans les tableaux
+	qui définissent la hitbox du bouton */
+	for (i = 0; i != largeur; i++) {
+		for (j = 0; j != hauteur; j++) {
+			if ((hitbox_largeur[i] == _X) && (hitbox_hauteur[j] == _Y)) {
+				return 1;
+			}
+		}
+	}
+	return 0;
+}
+
+void previsualisation_grille(int taille_grille) {
+	int i;
+	int j;
+	int cote_par_carre = (102/taille_grille);
+	for (i = 0; i != taille_grille; i++) {
+		for (j = 0; j != taille_grille; j++) {
+			ChoisirCouleurDessin(CouleurParNom("black"));
+			DessinerRectangle(194 + (cote_par_carre*i), 40 + (cote_par_carre*j), cote_par_carre, cote_par_carre);
+		}
+	}
+}
+
+void affiche_selection_taille_grille(int taille_grille) {
+	couleur c;
+	char nouv_taille_grille[1];
+	sprintf(nouv_taille_grille, "%d", taille_grille);
+	c = CouleurParNom("black");
+	ChoisirCouleurDessin(c);
+	EcrireTexte(117,200,"Taille de la grille : ", 2);
+	printf("%d",TailleChaineEcran("Taille de la grille : ", 2));
+	EcrireTexte(367,200,nouv_taille_grille, 2);
+	DessinerSegment(124,250,376,250);
+	DessinerSegment(125,251,375,251);
+	DessinerSegment(125,249,375,249);
+	DessinerArc(114+(42*(taille_grille-3)),240,20,20,0,360);
+	DessinerArc(113+(42*(taille_grille-3)),239,22,22,0,360);
+	c = CouleurParNom("grey");
+	ChoisirCouleurDessin(c);
+	RemplirArc(114+(42*(taille_grille-3)),240,20,20,0,360);
+}
+
+void affiche_fleches(void) {
+	/* Flèche gauche */
+	DessinerSegment(105,242, 105,257);
+	DessinerSegment(105,242, 97, 250);
+	DessinerSegment(97, 250, 105,257);
+	/* Flèche droite */
+	DessinerSegment(400,242, 400,257);
+	DessinerSegment(400,242, 408,250);
+	DessinerSegment(408,250, 400,257);
+}
+
+int main(void) {
+	int test = 1;
+	int bouton_taille_x = 114;
+	int taille_grille = 3;
+	InitialiserGraphique();
+	CreerFenetre(100,100,500,500);
+	affiche_boutons();
+	affiche_selection_taille_grille(taille_grille);
+	previsualisation_grille(taille_grille);
+	affiche_fleches();
+	while (1) {
+		if (souris_clique_bouton(150,375,200,50)) { 
+			FermerGraphique();
+			return EXIT_SUCCESS;
+		}
+		if (souris_clique_bouton(150,375,200,50)) {
+			/* Lancer le code du jeu */
+		}
+		if (ToucheEnAttente()) {
+			int touche = (Touche());
+			if (touche == XK_Left && taille_grille > 3) {
+				taille_grille--;
+				affiche_boutons();
+				affiche_selection_taille_grille(taille_grille);
+				previsualisation_grille(taille_grille);
+				affiche_fleches();
+			}
+			if (touche == XK_Right && taille_grille < 9) {
+				taille_grille++;
+				affiche_boutons();
+				affiche_selection_taille_grille(taille_grille);
+				previsualisation_grille(taille_grille);
+				affiche_fleches();
+			}
+		}
+	} 
+}

DEV1.1/SAé/menu_principal_v2.c

@@ -0,0 +1,190 @@
+# include <stdio.h>
+# include <stdlib.h>
+# include <graph.h>
+
+
+void affiche_boutons_joueurs(void) {
+	/* Initialise le graphique et le ferme SEULEMENT si l'utilisateur ferme la 
+	fenêtre ou appuie sur QUITTER */
+	couleur c;
+	c = CouleurParNom("white");
+	EffacerEcran(c);
+	c = CouleurParNom("black");
+	ChoisirCouleurDessin(c);
+	DessinerRectangle(150,300,200,50);
+	DessinerRectangle(150,360,200,50);
+	DessinerRectangle(150,420,200,50);
+	c = CouleurParComposante(0, 129, 60);
+	ChoisirCouleurDessin(c);
+	EcrireTexte(188,457, "QUITTER", 2);
+	c = CouleurParNom("dark blue");
+	ChoisirCouleurDessin(c);
+	EcrireTexte(233,337, "1J", 2);
+	EcrireTexte(233,397, "2J", 2);
+
+}
+
+
+void affiche_boutons(void) {
+	/* Initialise le graphique et le ferme SEULEMENT si l'utilisateur ferme la 
+	fenêtre ou appuie sur QUITTER */
+	couleur c;
+	c = CouleurParNom("white");
+	EffacerEcran(c);
+	c = CouleurParNom("black");
+	ChoisirCouleurDessin(c);
+	DessinerRectangle(150,300,200,50);
+	DessinerRectangle(150,375,200,50);
+	c = CouleurParComposante(0, 129, 60);
+	ChoisirCouleurDessin(c);
+	EcrireTexte(188,412, "QUITTER", 2);
+	c = CouleurParNom("dark blue");
+	ChoisirCouleurDessin(c);
+	EcrireTexte(200,337, "JOUER", 2);
+}
+
+
+int souris_clique_bouton(int bouton_x, int bouton_y, int largeur, int hauteur) {
+	/* Prend en argument les coordonnées x et y du point en haut
+	à gauche du bouton, sa largeur et sa hauteur puis renvoie un booléen si 
+	la souris clique dans la zone du bouton (0 si oui, 1 sinon) */
+	int hitbox_largeur[500];
+	int hitbox_hauteur[500];
+	int i;
+	int j;
+	SourisCliquee();
+
+	/* Remplit le tableau hitbox_largeur avec toutes les coordonnées x qui correspondent
+	à celles du bouton */
+	for (i = 0; i != largeur; i++) {
+		hitbox_largeur[i] = i + bouton_x;
+	}
+
+	/* Remplit le tableau hitbox_hauteur avec toutes les coordonnées y qui correspondent
+	à celles du bouton */
+	for (i = 0; i != hauteur; i++) {
+		hitbox_hauteur[i] = i + bouton_y;
+	}
+
+	/* Vérifie si les coordonnées de la souris sont présentes dans les tableaux
+	qui définissent la hitbox du bouton */
+	for (i = 0; i != largeur; i++) {
+		for (j = 0; j != hauteur; j++) {
+			if ((hitbox_largeur[i] == _X) && (hitbox_hauteur[j] == _Y)) {
+				return 1;
+			}
+		}
+	}
+	return 0;
+}
+
+void previsualisation_grille(int taille_grille) {
+	int i;
+	int j;
+	int cote_par_carre = (102/taille_grille);
+	for (i = 0; i != taille_grille; i++) {
+		for (j = 0; j != taille_grille; j++) {
+			ChoisirCouleurDessin(CouleurParNom("black"));
+			DessinerRectangle(194 + (cote_par_carre*i), 40 + (cote_par_carre*j), cote_par_carre, cote_par_carre);
+		}
+	}
+}
+
+void affiche_selection_taille_grille(int taille_grille) {
+	couleur c;
+	char nouv_taille_grille[20];
+	sprintf(nouv_taille_grille, "%d", taille_grille);
+	c = CouleurParNom("black");
+	ChoisirCouleurDessin(c);
+	EcrireTexte(117,200,"Taille de la grille : ", 2);
+	EcrireTexte(367,200,nouv_taille_grille, 2);
+	DessinerSegment(124,250,376,250);
+	DessinerSegment(125,251,375,251);
+	DessinerSegment(125,249,375,249);
+	DessinerArc(114+(42*(taille_grille-3)),240,20,20,0,360);
+	DessinerArc(113+(42*(taille_grille-3)),239,22,22,0,360);
+	c = CouleurParNom("grey");
+	ChoisirCouleurDessin(c);
+	RemplirArc(114+(42*(taille_grille-3)),240,20,20,0,360);
+}
+
+void affiche_fleches(void) {
+	ChoisirCouleurDessin(CouleurParNom("black"));
+	/* Flèche gauche */
+	DessinerSegment(105,242, 105,257);
+	DessinerSegment(105,242, 97, 250);
+	DessinerSegment(97, 250, 105,257);
+	/* Flèche droite */
+	DessinerSegment(400,242, 400,257);
+	DessinerSegment(400,242, 408,250);
+	DessinerSegment(408,250, 400,257);
+}
+
+int main(void) {
+	int test = 1;
+	int bouton_taille_x = 114;
+	int taille_grille = 3;
+	int sous_menu = 0;
+	InitialiserGraphique();
+	CreerFenetre(100,100,500,500);
+	affiche_boutons();
+	affiche_selection_taille_grille(taille_grille);
+	previsualisation_grille(taille_grille);
+	affiche_fleches();
+	while (1) {
+		if (sous_menu) { 
+			if (souris_clique_bouton(150,420,200,50)) {
+				affiche_boutons();
+				affiche_selection_taille_grille(taille_grille);
+				affiche_fleches();
+				previsualisation_grille(taille_grille);
+				sous_menu = 0;
+			}
+			else if (souris_clique_bouton(150,300,200,50)) {
+				/* Lance le code d'une partie à 1 joueur */
+			}
+			else if (souris_clique_bouton(150,360,200,50)) {
+				/* Lance le code d'une partie à 2 joueurs */
+			}
+		}
+		else if (!sous_menu && souris_clique_bouton(150,300,200,50)) {
+			sous_menu = 1;
+			affiche_boutons_joueurs();
+			affiche_selection_taille_grille(taille_grille);
+			affiche_fleches();
+			previsualisation_grille(taille_grille);
+		}
+		else if (!sous_menu && SourisCliquee() && souris_clique_bouton(150,375,200,50)) {
+				FermerGraphique();
+				return EXIT_SUCCESS;
+		}
+		
+		if (ToucheEnAttente()) {
+			int touche = (Touche());
+			if (touche == XK_Left && taille_grille > 3) {
+				taille_grille--;
+				if (sous_menu) {
+					affiche_boutons_joueurs();
+				}
+				else {
+					affiche_boutons();
+				}
+				affiche_selection_taille_grille(taille_grille);
+				previsualisation_grille(taille_grille);
+				affiche_fleches();
+			}
+			if (touche == XK_Right && taille_grille < 9) {
+				taille_grille++;
+				if (sous_menu) {
+					affiche_boutons_joueurs();
+				}
+				else {
+					affiche_boutons();
+				}
+				affiche_selection_taille_grille(taille_grille);
+				previsualisation_grille(taille_grille);
+				affiche_fleches();
+			}
+		}
+	} 
+}

DEV1.1/SAé/test.c

@@ -0,0 +1,43 @@
+# include <stdio.h>
+# include <stdlib.h>
+int deplacement_possible(int joueur, int grille[9][9], int taille_grille) {
+	/* Renvoie 1 si un déplacement est possible, 0 sinon */
+	int i,j;
+	int pos_joueur_x, pos_joueur_y;
+
+	for (i = 0; i != taille_grille; i++) {
+		for (j = 0; j != taille_grille; j++) {
+			if (grille[i][j] == joueur) {
+				pos_joueur_x = i;
+				pos_joueur_y = j;
+			}
+		}
+	}
+
+
+	for (i = (pos_joueur_x-1); i != (pos_joueur_x+2); i++) {
+		for (j = (pos_joueur_y-1); j != (pos_joueur_y+2); j++) {
+			printf("%d ; %d\n", i, j);
+			if (grille[i][j] == 0 && i < taille_grille && j < taille_grille && i >= 0 && j >= 0) {
+				return 1;
+			}
+		}
+	}
+	return 0;
+}
+
+int main(void) {
+	int grille[9][9] = {
+		{0,2,0},
+		{3,3,4},
+		{0,0,1},
+	};
+	int taille_grille = 3;
+	if (deplacement_possible(1, grille, taille_grille)) {
+		printf("Possible.\n");
+	}
+	else {
+		printf("Impossible. \n");
+	}
+	return EXIT_SUCCESS;
+}

DEV1.1/SAé/test2.c

@@ -0,0 +1,16 @@
+# include <stdio.h>
+# include <stdlib.h>
+
+
+int main(int argc, char** argv) {
+	int pion_x, pion_y;
+	int taille_grille;
+	srand(time(NULL));
+	printf("Taille de la grille : ");
+	scanf("%d",&taille_grille);
+	putchar('\n');
+	pion_x = (rand() % taille_grille);
+	pion_y = (rand() % taille_grille);
+	printf("%d, %d\n", pion_x, pion_y);
+	return EXIT_SUCCESS;
+}

DEV1.1/TP20/TP20_reponses.txt

@@ -0,0 +1,91 @@
+----- TP20 : Structures -----
+
+1. 
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+int main (void) {
+	time_t timestamp = time(NULL);
+	struct tm* date = localtime(&timestamp);
+
+	printf("%04d/%02d/%02d", date->tm_year+1900, date->tm_mon+1, date->tm_mday);
+}
+
+
+2.
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+struct enregistrement {
+	char a;
+	char b;
+	char c;
+};
+
+int main (void) {
+	struct enregistrement test = {'Z', 'i', 'o'};
+	printf("Taille du 1er élément : %zu \nTaille du 2e élément : %zu \nTaille du 3e élément : %zu \n", sizeof(test.a), sizeof(test.b), sizeof(test.c));
+}
+
+3.
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <pwd.h>
+
+
+int main (void) {
+	struct passwd* id = getpwnam("simoes");
+	printf("UID : %d\n", id->pw_uid);
+}
+
+4.
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+struct imaginaire {
+	int x;
+	int y;
+};
+
+struct imaginaire conjugue(struct imaginaire z) {
+	struct imaginaire z_conjugue;
+	z_conjugue.x = z.x;
+	z_conjugue.y = z.y * -1;
+	return z_conjugue;
+}
+
+double module(struct imaginaire z) {
+	return sqrt((z.x*z.x) + (z.y*z.y));
+}
+
+void afficher_imaginaire(struct imaginaire z) {
+	if (z.y < 0) {
+		printf("%d - %di", z.x, z.y*-1);
+	} 
+	else {
+		printf("%d + %di", z.x, z.y);
+	}
+	putchar('\n');
+}
+
+void inverse(struct imaginaire z) {
+	printf("1 / ");
+	afficher_imaginaire(z);
+}
+
+int main (void) {
+	struct imaginaire test = {4, 8};
+	afficher_imaginaire(test);
+	afficher_imaginaire(conjugue(test));
+	printf("%f\n",module(test));
+	inverse(test);
+}
+

DEV1.1/TP20/tests.c

@@ -0,0 +1,42 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+struct imaginaire {
+	int x;
+	int y;
+};
+
+struct imaginaire conjugue(struct imaginaire z) {
+	struct imaginaire z_conjugue;
+	z_conjugue.x = z.x;
+	z_conjugue.y = z.y * -1;
+	return z_conjugue;
+}
+
+double module(struct imaginaire z) {
+	return sqrt((z.x*z.x) + (z.y*z.y));
+}
+
+void afficher_imaginaire(struct imaginaire z) {
+	if (z.y < 0) {
+		printf("%d - %di", z.x, z.y*-1);
+	} 
+	else {
+		printf("%d + %di", z.x, z.y);
+	}
+	putchar('\n');
+}
+
+void inverse(struct imaginaire z) {
+	printf("1 / ");
+	afficher_imaginaire(z);
+}
+
+int main (void) {
+	struct imaginaire test = {4, 8};
+	afficher_imaginaire(test);
+	afficher_imaginaire(conjugue(test));
+	printf("%f\n",module(test));
+	inverse(test);
+}

DEV1.1/TP21/TP21_reponses.txt

@@ -0,0 +1,45 @@
+------ TP21 : Fichier ------
+
+
+1. 
+
+# include <stdio.h>
+# include <stdlib.h>
+
+int main(void) {
+	FILE* fichier = NULL;
+	int score;
+	char caractere;
+	char sigle[3];
+	int resultat;
+	int i;
+	int lu;
+
+	fichier = fopen("top10", "r");
+	if (fichier == NULL) {
+		printf("Erreur d'ouverture.\n");
+		return EXIT_FAILURE;
+	}
+
+	lu = fread(&resultat, sizeof(int), 1, fichier);
+	for (i = 0; i != 3; i++) {
+		lu = fread(&caractere, sizeof(char), 1, fichier);
+		sigle[i] = caractere;
+	}
+	
+	while (lu == 1) {
+		printf("%09d ", resultat);
+		for (i = 0; i != 3; i++) {
+			putchar(sigle[i]);
+		}
+		putchar('\n');
+		lu = fread(&resultat, sizeof(int), 1, fichier);
+		for (i = 0; i != 3; i++) {
+			lu = fread(&caractere, sizeof(char), 1, fichier);
+			sigle[i] = caractere;
+		}
+	}
+	fclose(fichier);
+	
+	return EXIT_SUCCESS;
+}

DEV1.1/TP21/test.c

@@ -0,0 +1,18 @@
+# include <stdio.h>
+# include <stdlib.h>
+
+int main(int argc, char** argv) {
+	FILE* fichier = NULL;
+	int score;
+	char caractere;
+	char sigle[3];
+	int resultat;
+	int i;
+	int j = 0;
+	int lu;
+	char liste_sigles[10][3];
+	int liste_resultats[10];
+	
+	
+	return EXIT_SUCCESS;
+}

DEV1.1/TP22/test.c

@@ -0,0 +1,11 @@
+# include <stdio.h>
+# include <stdlib.h>
+# include <graph.h>
+
+int main(void) {
+	FILE* fichier = NULL;
+	int i;
+	int valeur;
+	
+	return EXIT_SUCCESS;
+}

DEV1.1/TP23/TP22-reponses.txt

@@ -0,0 +1,122 @@
+----- TP22 : Fichiers (encore) -----
+
+1. 
+
+# include <stdio.h>
+# include <stdlib.h>
+
+int main(int argc, char** argv) {
+	FILE* fichier = NULL;
+	char* lu;
+	char* contenu;
+	int compteur = 1;
+	fichier = fopen(argv[1], "r");
+	if (fichier == NULL) {
+		printf("Erreur d'écriture");
+		return EXIT_FAILURE;
+	}
+	lu = fgets(contenu, 1000, fichier);
+	while (lu != NULL) {
+		printf("%d ", compteur);
+		printf(contenu);
+		putchar('\n');
+		lu = fgets(contenu, 1000, fichier);
+		compteur++;
+	} 
+	fclose(fichier);
+
+
+	return EXIT_SUCCESS;
+}
+
+2.
+
+int main(void) {
+	/* Déclaration des tableaux */
+	int t1[2][5];
+	int t2[3][5];
+	int t3[5][5];
+	int compteur;
+	/* Remplissage des tableaux */
+	int i;
+	int j;
+	/* t1 */
+	for (i = 0; i != 2; i++) {
+		for (j = 0; j != 5; j++) {
+			t1[i][j] = j + 1;
+		}
+	}
+	/* t2 */
+	compteur = 1;
+	for (i = 0; i != 3; i++) {
+		for (j = 0; j != 5; j++) {
+			t2[i][j] = compteur;
+			compteur++;
+		}
+	}
+	/* t3 */
+	compteur = 0;
+	for (i = 0; i != 5; i++) {
+		for (j = 0; j != 5; j++) {
+			if  (j >= i) {
+				t3[i][j] = 0;
+			}
+			else {
+				t3[i][j] = 1 + j;
+			}
+		}
+	}
+	/* Affichage des tableaux */
+	/* t1 */
+	for (i = 0; i != 2; i++) {
+		for (j = 0; j != 5; j++) {
+			printf("%d ", t1[i][j]);
+		}
+		printf("\n");
+	}
+	printf("\n");
+	/* t2 */
+	for (i = 0; i != 3; i++) {
+		for (j = 0; j != 5; j++) {
+			printf("%d ", t2[i][j]);
+		}
+		printf("\n");
+	}
+	printf("\n");
+	/* t3 */
+	for (i = 0; i != 5; i++) {
+		for (j = 0; j != 5; j++) {
+			printf("%d ", t3[i][j]);
+		}
+		printf("\n");
+	}
+	printf("\n");
+
+	/* Inversions lignes-colonnes */
+	/* t1 */
+	for (j = 0; j != 5; j++) {
+		for (i = 0; i != 2; i++) {
+			printf("%d ", t1[i][j]);
+		}
+		printf("\n");
+	}
+	printf("\n");
+	/* t2 */
+	for (j = 0; j != 5; j++) {
+		for (i = 0; i != 3; i++) {
+			printf("%d ", t2[i][j]);
+		}
+		printf("\n");
+	}
+	printf("\n");
+	/* t3 */
+	for (j = 0; j != 5; j++) {
+		for (i = 0; i != 5; i++) {
+			printf("%d ", t3[i][j]);
+		}
+		printf("\n");
+	}
+	printf("\n");
+
+	return EXIT_SUCCESS;
+}

DEV1.1/TP23/test.c

@@ -0,0 +1,55 @@
+# include <stdio.h>
+# include <stdlib.h>
+
+int main(void) {
+	/* Déclaration des tableaux */
+	int t1[2][5];
+	int t2[3][5];
+	int t3[5][5];
+	FILE* fichier = NULL;
+	int compteur;
+	/* Remplissage des tableaux */
+	int i;
+	int j;
+	/* t1 */
+	for (i = 0; i != 2; i++) {
+		for (j = 0; j != 5; j++) {
+			t1[i][j] = j + 1;
+		}
+	}
+	/* t2 */
+	compteur = 1;
+	for (i = 0; i != 3; i++) {
+		for (j = 0; j != 5; j++) {
+			t2[i][j] = compteur;
+			compteur++;
+		}
+	}
+	/* t3 */
+	compteur = 0;
+	for (i = 0; i != 5; i++) {
+		for (j = 0; j != 5; j++) {
+			if  (j >= i) {
+				t3[i][j] = 0;
+			}
+			else {
+				t3[i][j] = 1 + j;
+			}
+		}
+	}
+	
+	fichier = fopen("t1.csv", "w");
+	if (fichier == NULL) {
+		printf("Erreur d'ouverture.\n");
+		return EXIT_FAILURE;
+	}
+
+	for (i = 0; i != 2; i++) {
+		for (j = 0; j != 2; j++) {
+			fputs(/* TODO */)
+		}
+	}
+	fclose(fichier);
+
+	return EXIT_SUCCESS;
+}

DEV1.1/TP23/texte.txt

@@ -0,0 +1,11 @@
+ Le premier argument est l'adresse de la zone mémoire qui va recevoir les données. Le deuxième est la capacité de cette zone. Le troisième est le flux de lecture. Cette fonction va copier jusqu'à capacite-1 caractères, à moins qu'il ne rencontre la fin du fichier ou un saut de ligne. Le saut de ligne sera également transféré. Un marqueur de fin de chaîne sera ensuite ajouté.
+
+La valeur renvoyée est l'adresse de la zone, ou NULL s'il y a eu une erreur ou si la fin du fichier est intervenue avant la lecture du moindre caractère.
+
+La fonction fscanf a pour prototype :
+
+int fscanf(FILE *flux, const char *format, ...);
+
+Elle fonctionne sur le même principe que scanf, mais en ajoutant un paramètre pour indiquer depuis quel flux lire.
+
+La valeur de retour est le nombre de valeurs interprétées, ou EOF en cas d'erreur ou si la fin du fichier est atteinte avant la moindre lecture. La constante EOF est obligatoirement négative (elle vaut -1 dans sa version GNU). 

DEV1.1/TP24/test.c

@@ -0,0 +1,28 @@
+# include <stdio.h>
+# include <stdlib.h>
+
+int main(int argc, char** argv) {
+	FILE* fichier = NULL;
+	char* lu;
+	char caractere;
+
+	fichier = fopen(argv[1], "r+");
+	if (fichier == NULL) {
+		printf("Erreur d'ouverture.\n");
+		return EXIT_FAILURE;
+	}
+
+	lu = fgets(&caractere, sizeof(char), fichier);
+	while (lu != NULL) {
+		if (caractere == 'e') {
+			printf("%c", )
+			fseek(fichier, -1, SEEK_CUR);
+			fputs("X", fichier);
+			fseek(fichier, 0, SEEK_CUR);
+		}
+		lu = fgets(&caractere, sizeof(char), fichier);
+	}
+
+	free(fichier);
+	return EXIT_SUCCESS;
+}

DEV1.1/TP24/test_e.txt

@@ -0,0 +1 @@
+Ceci est un test avec des e.

DEV1.1/TP25/test.c

@@ -0,0 +1,28 @@
+# include <stdio.h>
+# include <stdlib.h>
+
+struct maillon {
+  int valeur;
+  struct maillon* suivant;
+};
+
+
+void creation_liste(struct maillon* liste) {
+	int i;
+	liste->valeur = (rand() % 888) + 111;
+	for (i = 0; i != 10; i++) {
+		struct maillon* prochain = (struct maillon*) malloc(sizeof(struct maillon*));
+		if (prochain == NULL) {
+			printf("Erreur d'allocation mémoire.\n");
+		}
+		prochain->valeur = (rand() % 888) + 111;
+		liste->suivant = prochain;
+	}
+}
+
+int main(void) {
+	struct maillon* liste = NULL;
+	srand(time(NULL));
+	creation_liste(liste);
+	return EXIT_SUCCESS;
+}

SAE11_2024

@@ -0,0 +1 @@
+Subproject commit ccc278083f90e240294b73ec7207f4e8d39b1268