mchauvel / Space_Invaders_Chauveliere_Martin

Commit 3c835d74abb76a2d297fce131699d754f3559fd4

Authored by Martin CHAUVELIERE
1 parent 4d73f71e

Premieres ameliorations visibilité

Showing 7 changed files with 267 additions and 202 deletions   Show diff stats
Inline Side-by-side
Interactif/Interactif.c
  Show/Hide comments   View file @3c835d7
@@ -12,34 +12,34 @@ @@ -12,34 +12,34 @@
12 #define ErreurHitbox 2 12 #define ErreurHitbox 2
13 13
14 14
15 -int CheckCollisionEntiteEntite(struct entite enti1, int L1, int H1, struct entite enti2, int L2, int H2) 15 +int CheckCollisionEntiteEntite(struct entite entite1, int L1, int H1, struct entite entite2, int L2, int H2)
16 { 16 {
17 //CheckX 17 //CheckX
18 - int gauche1 = enti1.posx - L1/2 + ErreurHitbox;  
19 - int droite1 = enti1.posx + L1/2 - ErreurHitbox;  
20 - int gauche2 = enti2.posx - L2/2 + ErreurHitbox;  
21 - int droite2 = enti2.posx + L2/2 - ErreurHitbox; 18 + int gauche1 = entite1.posx - L1/2 + ErreurHitbox;
  19 + int droite1 = entite1.posx + L1/2 - ErreurHitbox;
  20 + int gauche2 = entite2.posx - L2/2 + ErreurHitbox;
  21 + int droite2 = entite2.posx + L2/2 - ErreurHitbox;
22 int CheckX = (gauche1 >= gauche2 && gauche1 <= droite2) || (droite1 >= gauche2 && droite1 <= droite2); 22 int CheckX = (gauche1 >= gauche2 && gauche1 <= droite2) || (droite1 >= gauche2 && droite1 <= droite2);
23 23
24 //CheckY 24 //CheckY
25 - int haut1 = enti1.posy - H1/2 + ErreurHitbox;  
26 - int bas1 = enti1.posy + H1/2 - ErreurHitbox;  
27 - int haut2 = enti2.posy - H2/2 + ErreurHitbox;  
28 - int bas2 = enti2.posy + H2/2 - ErreurHitbox; 25 + int haut1 = entite1.posy - H1/2 + ErreurHitbox;
  26 + int bas1 = entite1.posy + H1/2 - ErreurHitbox;
  27 + int haut2 = entite2.posy - H2/2 + ErreurHitbox;
  28 + int bas2 = entite2.posy + H2/2 - ErreurHitbox;
29 int CheckY = (haut1 <= bas2 && haut1 >= haut2) || (bas1 <= bas2 && bas1 >= haut2); 29 int CheckY = (haut1 <= bas2 && haut1 >= haut2) || (bas1 <= bas2 && bas1 >= haut2);
30 30
31 return CheckX && CheckY; 31 return CheckX && CheckY;
32 } 32 }
33 33
34 34
35 -struct entite* CheckCollisionListeEntite(struct liste_entite *Liste1,int L1,int H1,struct entite enti2, int L2, int H2) 35 +struct entite* CheckCollisionListeEntite(struct liste_entite *Liste1,int L1,int H1,struct entite entite2, int L2, int H2)
36 { 36 {
37 struct liste_entite *pL1=Liste1; 37 struct liste_entite *pL1=Liste1;
38 while (pL1 != NULL) 38 while (pL1 != NULL)
39 { 39 {
40 - if(CheckCollisionEntiteEntite(pL1->enti,L1,H1,enti2,L2,H2) == 1) 40 + if(CheckCollisionEntiteEntite(pL1->entite,L1,H1,entite2,L2,H2) == 1)
41 { 41 {
42 - return &pL1->enti; 42 + return &pL1->entite;
43 } 43 }
44 pL1=pL1->suivant; 44 pL1=pL1->suivant;
45 } 45 }
@@ -54,22 +54,22 @@ struct liste_entite* CheckCollisionListeListe(struct liste_entite *Liste1,int L1 @@ -54,22 +54,22 @@ struct liste_entite* CheckCollisionListeListe(struct liste_entite *Liste1,int L1
54 struct liste_entite *pL2=Liste2; 54 struct liste_entite *pL2=Liste2;
55 while (pL2 != NULL) 55 while (pL2 != NULL)
56 { 56 {
57 - struct entite* collision = CheckCollisionListeEntite(Liste1,L1,H1,pL2->enti,L2,H2); 57 + struct entite* collision = CheckCollisionListeEntite(Liste1,L1,H1,pL2->entite,L2,H2);
58 if (collision != NULL) 58 if (collision != NULL)
59 { 59 {
60 // Création des nœuds pour les deux entités 60 // Création des nœuds pour les deux entités
61 - struct liste_entite* Enti1 = malloc(sizeof(struct liste_entite));  
62 - struct liste_entite* Enti2 = malloc(sizeof(struct liste_entite)); 61 + struct liste_entite* Entite1 = malloc(sizeof(struct liste_entite));
  62 + struct liste_entite* Entite2 = malloc(sizeof(struct liste_entite));
63 63
64 // Remplissage des nœuds avec les entités correspondantes 64 // Remplissage des nœuds avec les entités correspondantes
65 - Enti1->enti = *collision;  
66 - Enti2->enti = pL2->enti; 65 + Entite1->entite = *collision;
  66 + Entite2->entite = pL2->entite;
67 67
68 // Relier les nœuds entre eux 68 // Relier les nœuds entre eux
69 - Enti1->suivant = Enti2;  
70 - Enti2->suivant = NULL; 69 + Entite1->suivant = Entite2;
  70 + Entite2->suivant = NULL;
71 71
72 - return Enti1; 72 + return Entite1;
73 } 73 }
74 else 74 else
75 pL2=pL2->suivant; 75 pL2=pL2->suivant;
@@ -86,16 +86,16 @@ int SupprimerEntitesEnCollision(struct liste_entite** Liste1, int L1, int H1, st @@ -86,16 +86,16 @@ int SupprimerEntitesEnCollision(struct liste_entite** Liste1, int L1, int H1, st
86 86
87 if (collision != NULL) { 87 if (collision != NULL) {
88 // Récupération des entités impliquées 88 // Récupération des entités impliquées
89 - struct entite* enti1 = &collision->enti;  
90 - struct entite* enti2 = &collision->suivant->enti; 89 + struct entite* entite1 = &collision->entite;
  90 + struct entite* entite2 = &collision->suivant->entite;
91 91
92 // Suppression de l'entité 1 de la liste 1 92 // Suppression de l'entité 1 de la liste 1
93 - SupprimerEntite(Liste1, enti1); 93 + SupprimerEntite(Liste1, entite1);
94 94
95 // Suppression de l'entité 2 de la liste 2 95 // Suppression de l'entité 2 de la liste 2
96 - SupprimerEntite(Liste2, enti2); 96 + SupprimerEntite(Liste2, entite2);
97 97
98 - afficherLutin(bouillie, enti2->posx - hitboxbouillieL/2 + ErreurHitbox, enti2->posy - hitboxbouillieH/2 + ErreurHitbox); 98 + afficherLutin(bouillie, entite2->posx - hitboxbouillieL/2 + ErreurHitbox, entite2->posy - hitboxbouillieH/2 + ErreurHitbox);
99 99
100 return 1; 100 return 1;
101 } 101 }
@@ -117,7 +117,7 @@ void Tirer(struct entite joueur, struct liste_entite **pl) @@ -117,7 +117,7 @@ void Tirer(struct entite joueur, struct liste_entite **pl)
117 117
118 void DeplacementTire(int tire, struct liste_entite** l) 118 void DeplacementTire(int tire, struct liste_entite** l)
119 { 119 {
120 - struct entite* ml = &(*l)->enti; 120 + struct entite* ml = &(*l)->entite;
121 if (ml != NULL) 121 if (ml != NULL)
122 { 122 {
123 if (ml->posy <= 0) 123 if (ml->posy <= 0)
@@ -180,9 +180,9 @@ void MakeBombeDroppable(struct liste_entite* enemies, struct liste_entite** bomb @@ -180,9 +180,9 @@ void MakeBombeDroppable(struct liste_entite* enemies, struct liste_entite** bomb
180 int taille = 0; 180 int taille = 0;
181 while (pL != NULL) 181 while (pL != NULL)
182 { 182 {
183 - if (pL->enti.dropbombe == 1) 183 + if (pL->entite.dropbombe == 1)
184 { 184 {
185 - ajout_tete(&Dropable,pL->enti); 185 + ajout_tete(&Dropable,pL->entite);
186 taille += 1; 186 taille += 1;
187 } 187 }
188 pL=pL->suivant; 188 pL=pL->suivant;
@@ -200,7 +200,7 @@ void MakeBombeDroppable(struct liste_entite* enemies, struct liste_entite** bomb @@ -200,7 +200,7 @@ void MakeBombeDroppable(struct liste_entite* enemies, struct liste_entite** bomb
200 { 200 {
201 pLDropable = pLDropable->suivant; 201 pLDropable = pLDropable->suivant;
202 } 202 }
203 - ajout_tete(bombes,creer_entite(pLDropable->enti.posx,pLDropable->enti.posy,-1)); 203 + ajout_tete(bombes,creer_entite(pLDropable->entite.posx,pLDropable->entite.posy,-1));
204 } 204 }
205 205
206 206
@@ -211,16 +211,16 @@ void DeplacementBombe(int bombe, struct liste_entite** l) @@ -211,16 +211,16 @@ void DeplacementBombe(int bombe, struct liste_entite** l)
211 211
212 while (ml != NULL) 212 while (ml != NULL)
213 { 213 {
214 - if (ml->enti.posy + hitboxbombeH/2 - ErreurHitbox >= Sol) 214 + if (ml->entite.posy + hitboxbombeH/2 - ErreurHitbox >= Sol)
215 { 215 {
216 - struct entite* a_supprimer = &ml->enti; 216 + struct entite* a_supprimer = &ml->entite;
217 ml = ml->suivant; 217 ml = ml->suivant;
218 SupprimerEntite(l, a_supprimer); 218 SupprimerEntite(l, a_supprimer);
219 } 219 }
220 else 220 else
221 { 221 {
222 - ml->enti.posy += 2;  
223 - afficherLutin(bombe, ml->enti.posx - hitboxbombeL/2 + ErreurHitbox, ml->enti.posy - hitboxbombeH/2 + ErreurHitbox); 222 + ml->entite.posy += 2;
  223 + afficherLutin(bombe, ml->entite.posx - hitboxbombeL/2 + ErreurHitbox, ml->entite.posy - hitboxbombeH/2 + ErreurHitbox);
224 precedent = ml; 224 precedent = ml;
225 ml = ml->suivant; 225 ml = ml->suivant;
226 } 226 }
1 #include <stdio.h> 1 #include <stdio.h>
2 #include <stdlib.h> 2 #include <stdlib.h>
3 #include <string.h> 3 #include <string.h>
  4 +
4 #include "Liste.h" 5 #include "Liste.h"
5 6
6 7
7 -struct entite creer_entite(int x, int y, int bombe) 8 +struct entite creer_entite (int x,
  9 + int y,
  10 + int bombe)
8 { 11 {
9 struct entite e; 12 struct entite e;
10 - e.posx = x;  
11 - e.posy = y; 13 +
  14 + e.posx = x;
  15 + e.posy = y;
12 e.dropbombe = bombe; 16 e.dropbombe = bombe;
  17 +
13 return e; 18 return e;
14 } 19 }
15 20
16 -void ajout_tete(struct liste_entite **pL, struct entite x)  
17 -{  
18 - struct liste_entite *tmp;  
19 - tmp = malloc(sizeof(struct liste_entite));  
20 - tmp->enti = x;  
21 - tmp->suivant = *pL;  
22 - *pL = tmp;  
23 -}  
24 21
25 22
26 -void imprimer_liste(struct liste_entite *l) 23 +void ajout_tete (struct liste_entite** Liste,
  24 + struct entite x )
27 { 25 {
28 - struct liste_entite *p;  
29 - p = l;  
30 - while (p != NULL)  
31 - {  
32 - printf("%d -> ",p->enti.posx);  
33 - p=p->suivant;  
34 - }  
35 - printf("\n"); 26 + struct liste_entite *Listetmp;
  27 +
  28 + Listetmp = malloc(sizeof(struct liste_entite));
  29 + Listetmp->entite = x;
  30 + Listetmp->suivant = *Liste;
  31 +
  32 + *Liste = Listetmp;
36 } 33 }
37 34
38 35
39 36
40 -void SupprimerEntite(struct liste_entite** Liste, struct entite* enti) 37 +void SupprimerEntite (struct liste_entite** Liste,
  38 + struct entite* entite)
41 { 39 {
42 - struct liste_entite* courant = *Liste; 40 + struct liste_entite* courant = *Liste;
43 struct liste_entite* precedent = NULL; 41 struct liste_entite* precedent = NULL;
44 42
45 while (courant != NULL) 43 while (courant != NULL)
46 { 44 {
47 - if (memcmp(&courant->enti, enti, sizeof(struct entite)) == 0) 45 +
  46 + if (memcmp (&courant->entite,
  47 + entite,
  48 + sizeof(struct entite)) == 0)
48 { 49 {
  50 +
49 if (precedent == NULL) 51 if (precedent == NULL)
50 { 52 {
51 *Liste = courant->suivant; 53 *Liste = courant->suivant;
52 } 54 }
  55 +
53 else 56 else
54 { 57 {
55 precedent->suivant = courant->suivant; 58 precedent->suivant = courant->suivant;
56 } 59 }
  60 +
57 free(courant); 61 free(courant);
58 break; 62 break;
59 } 63 }
  64 +
60 precedent = courant; 65 precedent = courant;
61 - courant = courant->suivant; 66 + courant = courant->suivant;
62 } 67 }
63 } 68 }
64 69
@@ -14,7 +14,7 @@ struct entite @@ -14,7 +14,7 @@ struct entite
14 14
15 struct liste_entite 15 struct liste_entite
16 { 16 {
17 - struct entite enti; 17 + struct entite entite;
18 struct liste_entite *suivant; 18 struct liste_entite *suivant;
19 }; 19 };
20 20
@@ -23,7 +23,5 @@ void ajout_tete(struct liste_entite**, struct entite); @@ -23,7 +23,5 @@ void ajout_tete(struct liste_entite**, struct entite);
23 23
24 struct entite creer_entite(int,int,int); 24 struct entite creer_entite(int,int,int);
25 25
26 -void imprimer_liste(struct liste_entite*);  
27 -  
28 void SupprimerEntite(struct liste_entite**,struct entite*); 26 void SupprimerEntite(struct liste_entite**,struct entite*);
29 27
1 #include <stdio.h> 1 #include <stdio.h>
2 #include <stdlib.h> 2 #include <stdlib.h>
  3 +
3 #include "../Graphique/libgraph.h" 4 #include "../Graphique/libgraph.h"
4 #include "../ListeC/Liste.h" 5 #include "../ListeC/Liste.h"
5 #include "../Interactif/Interactif.h" 6 #include "../Interactif/Interactif.h"
@@ -14,80 +15,113 @@ @@ -14,80 +15,113 @@
14 15
15 struct entite joueur; 16 struct entite joueur;
16 17
17 -int canon=0;  
18 -int missile=0;  
19 -int sbire=0;  
20 -int bouillie=0;  
21 -int bombe=0;  
22 -  
23 -char Nom[15]="Space Invader";  
24 -char input='\0'; 18 +int canon = 0;
  19 +int missile = 0;
  20 +int sbire = 0;
  21 +int bouillie = 0;
  22 +int bombe = 0;
25 23
26 -int hitboxcanonL=0;  
27 -int hitboxcanonH=0;  
28 -int hitboxmissileL=0;  
29 -int hitboxmissileH=0;  
30 -int hitboxsbireL=0;  
31 -int hitboxsbireH=0;  
32 -int hitboxbouillieL=0;  
33 -int hitboxbouillieH=0;  
34 -int hitboxbombeL=0;  
35 -int hitboxbombeH=0; 24 +int hitboxcanonL = 0;
  25 +int hitboxcanonH = 0;
  26 +int hitboxmissileL = 0;
  27 +int hitboxmissileH = 0;
  28 +int hitboxsbireL = 0;
  29 +int hitboxsbireH = 0;
  30 +int hitboxbouillieL = 0;
  31 +int hitboxbouillieH = 0;
  32 +int hitboxbombeL = 0;
  33 +int hitboxbombeH = 0;
36 34
  35 +char Nom[] = "Space Invader";
  36 +char input = '\0';
37 37
38 38
39 void initialiser() 39 void initialiser()
40 { 40 {
41 - canon = chargerLutin("../../Lutins/invader_canon.bmp",COULEUR_NOIR);  
42 - missile = chargerLutin("../../Lutins/invader_missile.bmp",COULEUR_NOIR);  
43 - sbire = chargerLutin("../../Lutins/invader_monstre1_1.bmp",COULEUR_NOIR);  
44 - bouillie = chargerLutin("../../Lutins/invader_monstre_bouillie.bmp",COULEUR_NOIR);  
45 - bombe = chargerLutin("../../Lutins/invader_bombe.bmp",COULEUR_NOIR);  
46 -  
47 - tailleLutin(canon,&hitboxcanonL,&hitboxcanonH);  
48 - tailleLutin(missile,&hitboxmissileL,&hitboxmissileH);  
49 - tailleLutin(sbire,&hitboxsbireL,&hitboxsbireH);  
50 - tailleLutin(bouillie,&hitboxbouillieL,&hitboxbouillieH);  
51 - tailleLutin(bombe,&hitboxbombeL,&hitboxbombeH); 41 + canon = chargerLutin ("../../Lutins/invader_canon.bmp",
  42 + COULEUR_NOIR);
  43 + missile = chargerLutin ("../../Lutins/invader_missile.bmp",
  44 + COULEUR_NOIR);
  45 + sbire = chargerLutin ("../../Lutins/invader_monstre1_1.bmp",
  46 + COULEUR_NOIR);
  47 + bouillie = chargerLutin ("../../Lutins/invader_monstre_bouillie.bmp",
  48 + COULEUR_NOIR);
  49 + bombe = chargerLutin ("../../Lutins/invader_bombe.bmp",
  50 + COULEUR_NOIR);
  51 +
  52 + tailleLutin (canon,
  53 + &hitboxcanonL,
  54 + &hitboxcanonH);
  55 + tailleLutin (missile,
  56 + &hitboxmissileL,
  57 + &hitboxmissileH);
  58 + tailleLutin (sbire,
  59 + &hitboxsbireL,
  60 + &hitboxsbireH);
  61 + tailleLutin (bouillie,
  62 + &hitboxbouillieL,
  63 + &hitboxbouillieH);
  64 + tailleLutin (bombe,
  65 + &hitboxbombeL,
  66 + &hitboxbombeH);
52 67
53 } 68 }
54 69
  70 +
55 void initialiserjoueur(struct entite* joueur) 71 void initialiserjoueur(struct entite* joueur)
56 { 72 {
57 - joueur->posx = JoueurX;  
58 - joueur->posy = JoueurY; 73 + joueur->posx = JoueurX;
  74 + joueur->posy = JoueurY;
59 joueur->dropbombe = -1; 75 joueur->dropbombe = -1;
60 } 76 }
61 77
62 78
63 -  
64 char pagedemarrage() 79 char pagedemarrage()
65 { 80 {
66 - static const char policeDefaut[]="/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf";  
67 - int Largeur, Hauteur;  
68 -  
69 - rectanglePlein(0,0,TailleX,TailleY,COULEUR_NOIR);  
70 - char jouer[26]="Appuyer sur j pour Jouer";  
71 - char quitter[30]="Appuyer ailleurs pour Quitter";  
72 -  
73 - choisirPolice(policeDefaut,50);  
74 - int Bienvenue = lutinTexte(Nom,COULEUR_VERT);  
75 - tailleLutin(Bienvenue,&Largeur,&Hauteur);  
76 - afficherLutin(Bienvenue,TailleX/2-Largeur/2,TailleY/4+Hauteur/2);  
77 -  
78 - choisirPolice(policeDefaut,20);  
79 -  
80 - int J = lutinTexte(jouer,COULEUR_BLANC);  
81 - tailleLutin(J,&Largeur,&Hauteur);  
82 - afficherLutin(J,TailleX/2-Largeur/2,TailleY/2-Hauteur/2);  
83 -  
84 - int Q = lutinTexte(quitter,COULEUR_BLANC);  
85 - tailleLutin(Q,&Largeur,&Hauteur);  
86 - afficherLutin(Q,TailleX/2-Largeur/2,TailleY/2+Hauteur/2); 81 + static const char policeDefaut[] = "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf";
  82 + int Largeur = 0;
  83 + int Hauteur = 0;
  84 + char jouer[] = "Appuyer sur j pour Jouer";
  85 + char quitter[] = "Appuyer ailleurs pour Quitter";
  86 +
  87 + choisirPolice (policeDefaut, TailleX / 20);
  88 + int LutinJouer = lutinTexte (jouer, COULEUR_BLANC);
  89 + int LutinQuitter = lutinTexte (quitter, COULEUR_BLANC);
  90 +
  91 + choisirPolice (policeDefaut,TailleX / 10);
  92 + int LutinBienvenue = lutinTexte (Nom, COULEUR_VERT);
  93 +
  94 + rectanglePlein (0,
  95 + 0,
  96 + TailleX,
  97 + TailleY,
  98 + COULEUR_NOIR);
  99 +
  100 + tailleLutin (LutinBienvenue,
  101 + &Largeur,
  102 + &Hauteur);
  103 + afficherLutin (LutinBienvenue,
  104 + TailleX / 2 - Largeur / 2,
  105 + TailleY / 4 + Hauteur / 2);
  106 +
  107 + tailleLutin (LutinJouer,
  108 + &Largeur,
  109 + &Hauteur);
  110 + afficherLutin (LutinJouer,
  111 + TailleX/2-Largeur/2,
  112 + TailleY/2-Hauteur/2);
  113 +
  114 + tailleLutin (LutinQuitter,
  115 + &Largeur,
  116 + &Hauteur);
  117 + afficherLutin (LutinQuitter,
  118 + TailleX / 2 - Largeur / 2,
  119 + TailleY / 2 + Hauteur / 2);
87 120
88 attendreEvenement (); 121 attendreEvenement ();
  122 +
89 input = touche(); 123 input = touche();
90 - while (input==''\0')') 124 + while (input == ''\0')')
91 { 125 {
92 input = touche(); 126 input = touche();
93 } 127 }
@@ -95,44 +129,64 @@ char pagedemarrage() @@ -95,44 +129,64 @@ char pagedemarrage()
95 } 129 }
96 130
97 131
98 -void pagemort(int vie) 132 +void pagemort (int nbr_vie)
99 { 133 {
100 - static const char policeDefaut[]="/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf";  
101 - int Largeur, Hauteur;  
102 -  
103 - rectanglePlein(0,0,TailleX,TailleY,COULEUR_NOIR);  
104 - char mort[16]="Vous etes mort";  
105 - char nbr_vie[30];  
106 - sprintf(nbr_vie, "Nombre de vie restante : %d", vie);  
107 -  
108 -  
109 - choisirPolice(policeDefaut,40);  
110 -  
111 - int M = lutinTexte(mort,COULEUR_ROUGE);  
112 - tailleLutin(M,&Largeur,&Hauteur);  
113 - afficherLutin(M,TailleX/2-Largeur/2,TailleY/4+Hauteur/2);  
114 -  
115 - choisirPolice(policeDefaut,20);  
116 -  
117 - int V = lutinTexte(nbr_vie,COULEUR_BLANC);  
118 - tailleLutin(V,&Largeur,&Hauteur);  
119 - afficherLutin(V,TailleX/2-Largeur/2,TailleY/2-Hauteur/2); 134 + static const char policeDefaut[] = "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf";
  135 + int Largeur = 0;
  136 + int Hauteur = 0;
  137 + char mort[] = "Vous etes mort";
  138 + char vie[30] = "\0";
  139 + sprintf(vie, "Nombre de vie restante : %d", nbr_vie);
  140 +
  141 + choisirPolice (policeDefaut, TailleX / 10);
  142 + int LutinMort = lutinTexte(mort, COULEUR_ROUGE);
  143 +
  144 + choisirPolice (policeDefaut, TailleX / 20);
  145 + int LutinVie = lutinTexte(vie, COULEUR_BLANC);
  146 +
  147 + rectanglePlein (0,
  148 + 0,
  149 + TailleX,
  150 + TailleY,
  151 + COULEUR_NOIR);
  152 +
  153 + tailleLutin (LutinMort,
  154 + &Largeur,
  155 + &Hauteur);
  156 + afficherLutin (LutinMort,
  157 + TailleX / 2 - Largeur / 2,
  158 + TailleY / 4 + Hauteur / 2);
  159 +
  160 + tailleLutin (LutinVie,
  161 + &Largeur,
  162 + &Hauteur);
  163 + afficherLutin (LutinVie,
  164 + TailleX / 2 - Largeur / 2,
  165 + TailleY / 2 - Hauteur / 2);
120 } 166 }
121 167
122 168
123 void pageGameOver() 169 void pageGameOver()
124 { 170 {
125 - static const char policeDefaut[]="/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf";  
126 - int Largeur, Hauteur;  
127 -  
128 - rectanglePlein(0,0,TailleX,TailleY,COULEUR_NOIR);  
129 - char fin[11]="GAME OVER";  
130 -  
131 - choisirPolice(policeDefaut,40);  
132 -  
133 - int F = lutinTexte(fin,COULEUR_ROUGE);  
134 - tailleLutin(F,&Largeur,&Hauteur);  
135 - afficherLutin(F,TailleX/2-Largeur/2,TailleY/2); 171 + static const char policeDefaut[] = "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf";
  172 + int Largeur = 0;
  173 + int Hauteur = 0;
  174 + char fin[] = "GAME OVER";
  175 +
  176 + choisirPolice(policeDefaut, TailleX / 10);
  177 + int LutinFin = lutinTexte(fin, COULEUR_ROUGE);
  178 +
  179 + rectanglePlein (0,
  180 + 0,
  181 + TailleX,
  182 + TailleY,
  183 + COULEUR_NOIR);
  184 +
  185 + tailleLutin (LutinFin,
  186 + &Largeur,
  187 + &Hauteur);
  188 + afficherLutin (LutinFin,
  189 + TailleX / 2 - Largeur / 2,
  190 + TailleY / 2 - Hauteur / 2);
136 191
137 } 192 }
138 -  
@@ -51,7 +51,6 @@ int main() @@ -51,7 +51,6 @@ int main()
51 if (nbr_vie > 0) 51 if (nbr_vie > 0)
52 { 52 {
53 pagemort(nbr_vie); 53 pagemort(nbr_vie);
54 - printf("%d \n",joueur.posx);  
55 majSurface(); 54 majSurface();
56 SDL_Delay(2000); 55 SDL_Delay(2000);
57 mort = 0; 56 mort = 0;
@@ -71,8 +70,8 @@ int main() @@ -71,8 +70,8 @@ int main()
71 rectanglePlein(0,0,TailleX,TailleY,COULEUR_NOIR); 70 rectanglePlein(0,0,TailleX,TailleY,COULEUR_NOIR);
72 rectanglePlein(0,Sol,TailleX,2,COULEUR_VERT); 71 rectanglePlein(0,Sol,TailleX,2,COULEUR_VERT);
73 72
74 - afficherLutin(canon,Ljoueur->enti.posx - hitboxcanonL/2 + ErreurHitbox,Ljoueur->enti.posy);  
75 - AfficherSbire(sbire,hitboxsbireL,hitboxsbireH,enemies); 73 + afficherLutin(canon,Ljoueur->entite.posx - hitboxcanonL/2 + ErreurHitbox,Ljoueur->entite.posy);
  74 + AfficherSbire(enemies,sbire,hitboxsbireL,hitboxsbireH);
76 75
77 if (DropAlea == 0) 76 if (DropAlea == 0)
78 { 77 {
@@ -86,7 +85,7 @@ int main() @@ -86,7 +85,7 @@ int main()
86 } 85 }
87 86
88 input = touche(); 87 input = touche();
89 - action(&Ljoueur->enti,input,&tires); 88 + action(&Ljoueur->entite,input,&tires);
90 89
91 if (compteur==10) 90 if (compteur==10)
92 { 91 {
1 #include <stdio.h> 1 #include <stdio.h>
2 #include <stdlib.h> 2 #include <stdlib.h>
  3 +
3 #include "../Graphique/libgraph.h" 4 #include "../Graphique/libgraph.h"
4 #include "../ListeC/Liste.h" 5 #include "../ListeC/Liste.h"
5 #include "Monstre.h" 6 #include "Monstre.h"
@@ -9,82 +10,90 @@ @@ -9,82 +10,90 @@
9 #define ErreurHitbox 2 10 #define ErreurHitbox 2
10 11
11 //Sens = 1 -> Va vers la droite 12 //Sens = 1 -> Va vers la droite
12 -void DeplacementSbire(struct liste_entite *l, int *psens, int speed) 13 +void DeplacementSbire(struct liste_entite* Liste,
  14 + int* SensDeplacement,
  15 + int Vitesse)
13 { 16 {
14 - int ind=0;  
15 - struct liste_entite *ml=l;  
16 - while(ml != NULL)  
17 - {  
18 - if (*psens==1)  
19 - {  
20 - ml->enti.posx+=speed;  
21 - if(ml->enti.posx>=9*TailleX/10)ind=1;  
22 - }  
23 - else  
24 - {  
25 - ml->enti.posx-=speed;  
26 - if(ml->enti.posx<=TailleX/10)ind=2;  
27 - }  
28 - ml=ml->suivant;  
29 - }  
30 - if (ind==1) 17 +
  18 + int ind = 0;
  19 + struct liste_entite* pListe = Liste;
  20 +
  21 + while (pListe != NULL)
31 { 22 {
32 - *psens=0;  
33 - struct liste_entite *ml2=l;  
34 - while(ml2 != NULL)  
35 - {  
36 - ml2->enti.posy+=30;  
37 - ml2=ml2->suivant;  
38 - } 23 + pListe->entite.posx += (*SensDeplacement == 1) ? Vitesse : -Vitesse;
  24 +
  25 + if (pListe->entite.posx >= 9 * TailleX / 10)
  26 + ind = 1;
  27 +
  28 + else if (pListe->entite.posx <= TailleX / 10)
  29 + ind = 2;
  30 +
  31 + pListe = pListe->suivant;
39 } 32 }
40 - else if (ind==2) 33 +
  34 + if (ind != 0)
41 { 35 {
42 - *psens=1;  
43 - struct liste_entite *ml2=l;  
44 - while(ml2 != NULL) 36 + *SensDeplacement = (ind == 1) ? 0 : 1;
  37 + struct liste_entite* p2Liste = Liste;
  38 +
  39 + while (p2Liste != NULL)
45 { 40 {
46 - ml2->enti.posy+=30;  
47 - ml2=ml2->suivant; 41 + p2Liste->entite.posy += 30;
  42 + p2Liste = p2Liste->suivant;
48 } 43 }
49 } 44 }
50 } 45 }
51 46
52 47
53 -  
54 -void LigneSbire(struct liste_entite **enemies,int nbr_enemies, int nbr_rangee) 48 +void LigneSbire (struct liste_entite** ListeSbire,
  49 + int nbr_enemies,
  50 + int nbr_rangee)
55 { 51 {
56 - for (int j=1; j<= nbr_rangee; j++) 52 +
  53 + for (int j = 1; j <= nbr_rangee; j++)
57 { 54 {
58 - int compteurY=j*TailleY/10;  
59 - int compteurX=TailleX/nbr_enemies; 55 + int compteurY = j * TailleY / 10;
  56 + int compteurX = TailleX / nbr_enemies;
60 57
61 - for (int i=0; i<nbr_enemies; i++) 58 + for (int i = 0; i < nbr_enemies; i++)
62 { 59 {
63 if (j == nbr_rangee) 60 if (j == nbr_rangee)
64 { 61 {
65 - ajout_tete(enemies,creer_entite(compteurX,compteurY,1));  
66 - compteurX +=2*TailleX/(3*nbr_enemies); 62 + ajout_tete(ListeSbire,
  63 + creer_entite(compteurX,
  64 + compteurY,
  65 + 1)
  66 + );
  67 + compteurX += 2 * TailleX / (3 * nbr_enemies);
67 } 68 }
  69 +
68 else 70 else
69 { 71 {
70 - ajout_tete(enemies,creer_entite(compteurX,compteurY,0));  
71 - compteurX +=2*TailleX/(3*nbr_enemies); 72 + ajout_tete(ListeSbire,
  73 + creer_entite(compteurX,
  74 + compteurY,
  75 + 0)
  76 + );
  77 + compteurX += 2 * TailleX / (3 * nbr_enemies);
72 } 78 }
73 } 79 }
74 } 80 }
75 } 81 }
76 82
77 -  
78 -  
79 83
80 -void AfficherSbire(int lutin, int L, int H, struct liste_entite *l) 84 +void AfficherSbire (struct liste_entite* Liste,
  85 + int lutin,
  86 + int Largeur,
  87 + int Hauteur)
81 { 88 {
82 - struct liste_entite *ml=l;  
83 - while(ml != NULL) 89 +
  90 + struct liste_entite* pListe = Liste;
  91 +
  92 + while (pListe != NULL)
84 { 93 {
85 - afficherLutin(lutin,ml->enti.posx - L/2 + ErreurHitbox,ml->enti.posy - H/2 + ErreurHitbox);  
86 - ml=ml->suivant; 94 + afficherLutin(lutin,
  95 + pListe->entite.posx - Largeur / 2 + ErreurHitbox,
  96 + pListe->entite.posy - Hauteur / 2 + ErreurHitbox);
  97 + pListe=pListe->suivant;
87 } 98 }
88 } 99 }
89 -  
90 -  
@@ -5,4 +5,4 @@ void DeplacementSbire(struct liste_entite*,int*,int); @@ -5,4 +5,4 @@ void DeplacementSbire(struct liste_entite*,int*,int);
5 5
6 void LigneSbire(struct liste_entite**,int,int); 6 void LigneSbire(struct liste_entite**,int,int);
7 7
8 -void AfficherSbire(int,int,int,struct liste_entite*); 8 +void AfficherSbire(struct liste_entite*,int,int,int);