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 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 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 22 int CheckX = (gauche1 >= gauche2 && gauche1 <= droite2) || (droite1 >= gauche2 && droite1 <= droite2);
23 23  
24 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 29 int CheckY = (haut1 <= bas2 && haut1 >= haut2) || (bas1 <= bas2 && bas1 >= haut2);
30 30  
31 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 37 struct liste_entite *pL1=Liste1;
38 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 44 pL1=pL1->suivant;
45 45 }
... ... @@ -54,22 +54,22 @@ struct liste_entite* CheckCollisionListeListe(struct liste_entite *Liste1,int L1
54 54 struct liste_entite *pL2=Liste2;
55 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 58 if (collision != NULL)
59 59 {
60 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 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 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 74 else
75 75 pL2=pL2->suivant;
... ... @@ -86,16 +86,16 @@ int SupprimerEntitesEnCollision(struct liste_entite** Liste1, int L1, int H1, st
86 86  
87 87 if (collision != NULL) {
88 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 92 // Suppression de l'entité 1 de la liste 1
93   - SupprimerEntite(Liste1, enti1);
  93 + SupprimerEntite(Liste1, entite1);
94 94  
95 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 100 return 1;
101 101 }
... ... @@ -117,7 +117,7 @@ void Tirer(struct entite joueur, struct liste_entite **pl)
117 117  
118 118 void DeplacementTire(int tire, struct liste_entite** l)
119 119 {
120   - struct entite* ml = &(*l)->enti;
  120 + struct entite* ml = &(*l)->entite;
121 121 if (ml != NULL)
122 122 {
123 123 if (ml->posy <= 0)
... ... @@ -180,9 +180,9 @@ void MakeBombeDroppable(struct liste_entite* enemies, struct liste_entite** bomb
180 180 int taille = 0;
181 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 186 taille += 1;
187 187 }
188 188 pL=pL->suivant;
... ... @@ -200,7 +200,7 @@ void MakeBombeDroppable(struct liste_entite* enemies, struct liste_entite** bomb
200 200 {
201 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 211  
212 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 217 ml = ml->suivant;
218 218 SupprimerEntite(l, a_supprimer);
219 219 }
220 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 224 precedent = ml;
225 225 ml = ml->suivant;
226 226 }
... ...
ListeC/Liste.c
  Show/Hide comments   View file @3c835d7
1 1 #include <stdio.h>
2 2 #include <stdlib.h>
3 3 #include <string.h>
  4 +
4 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 12 struct entite e;
10   - e.posx = x;
11   - e.posy = y;
  13 +
  14 + e.posx = x;
  15 + e.posy = y;
12 16 e.dropbombe = bombe;
  17 +
13 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 41 struct liste_entite* precedent = NULL;
44 42  
45 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 51 if (precedent == NULL)
50 52 {
51 53 *Liste = courant->suivant;
52 54 }
  55 +
53 56 else
54 57 {
55 58 precedent->suivant = courant->suivant;
56 59 }
  60 +
57 61 free(courant);
58 62 break;
59 63 }
  64 +
60 65 precedent = courant;
61   - courant = courant->suivant;
  66 + courant = courant->suivant;
62 67 }
63 68 }
64 69  
... ...
ListeC/Liste.h
  Show/Hide comments   View file @3c835d7
... ... @@ -14,7 +14,7 @@ struct entite
14 14  
15 15 struct liste_entite
16 16 {
17   - struct entite enti;
  17 + struct entite entite;
18 18 struct liste_entite *suivant;
19 19 };
20 20  
... ... @@ -23,7 +23,5 @@ void ajout_tete(struct liste_entite**, struct entite);
23 23  
24 24 struct entite creer_entite(int,int,int);
25 25  
26   -void imprimer_liste(struct liste_entite*);
27   -
28 26 void SupprimerEntite(struct liste_entite**,struct entite*);
29 27  
... ...
Main/init.c
  Show/Hide comments   View file @3c835d7
1 1 #include <stdio.h>
2 2 #include <stdlib.h>
  3 +
3 4 #include "../Graphique/libgraph.h"
4 5 #include "../ListeC/Liste.h"
5 6 #include "../Interactif/Interactif.h"
... ... @@ -14,80 +15,113 @@
14 15  
15 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 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 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 75 joueur->dropbombe = -1;
60 76 }
61 77  
62 78  
63   -
64 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 121 attendreEvenement ();
  122 +
89 123 input = touche();
90   - while (input==''\0')')
  124 + while (input == ''\0')')
91 125 {
92 126 input = touche();
93 127 }
... ... @@ -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 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   -
... ...
Main/main.c
  Show/Hide comments   View file @3c835d7
... ... @@ -51,7 +51,6 @@ int main()
51 51 if (nbr_vie > 0)
52 52 {
53 53 pagemort(nbr_vie);
54   - printf("%d \n",joueur.posx);
55 54 majSurface();
56 55 SDL_Delay(2000);
57 56 mort = 0;
... ... @@ -71,8 +70,8 @@ int main()
71 70 rectanglePlein(0,0,TailleX,TailleY,COULEUR_NOIR);
72 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 76 if (DropAlea == 0)
78 77 {
... ... @@ -86,7 +85,7 @@ int main()
86 85 }
87 86  
88 87 input = touche();
89   - action(&Ljoueur->enti,input,&tires);
  88 + action(&Ljoueur->entite,input,&tires);
90 89  
91 90 if (compteur==10)
92 91 {
... ...
Monstre/Monstre.c
  Show/Hide comments   View file @3c835d7
1 1 #include <stdio.h>
2 2 #include <stdlib.h>
  3 +
3 4 #include "../Graphique/libgraph.h"
4 5 #include "../ListeC/Liste.h"
5 6 #include "Monstre.h"
... ... @@ -9,82 +10,90 @@
9 10 #define ErreurHitbox 2
10 11  
11 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 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 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   -
... ...
Monstre/Monstre.h
  Show/Hide comments   View file @3c835d7
... ... @@ -5,4 +5,4 @@ void DeplacementSbire(struct liste_entite*,int*,int);
5 5  
6 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);
... ...