Amelioration Collisions et Deplacements

Martin CHAUVELIERE
1 parent 0cc8564c
Showing 9 changed files with 203 additions and 156 deletions Show diff stats
Interactif/Interactif.c
Interactif/Interactif.h
ListeC/Liste.c
ListeC/Liste.h
Main/init.c
Main/init.h
Main/main.c
Monstre/Monstre.c
Monstre/Monstre.h
@@ -8,23 +8,24 @@
  
 #define TailleX 500
 #define TailleY 500
+#define Sol 475
 #define ErreurHitbox 2
  
  
 int CheckCollisionEntiteEntite(struct entite enti1, int L1, int H1, struct entite enti2, int L2, int H2)
 {
     //CheckX
-    int gauche1 = enti1.posx + ErreurHitbox;
-    int droite1 = enti1.posx + L1 - ErreurHitbox;
-    int gauche2 = enti2.posx + ErreurHitbox;
-    int droite2 = enti2.posx + L2 - ErreurHitbox;
+    int gauche1 = enti1.posx - L1/2 + ErreurHitbox;
+    int droite1 = enti1.posx + L1/2 - ErreurHitbox;
+    int gauche2 = enti2.posx - L2/2 + ErreurHitbox;
+    int droite2 = enti2.posx + L2/2 - ErreurHitbox;
     int CheckX = (gauche1 >= gauche2 && gauche1 <= droite2) || (droite1 >= gauche2 && droite1 <= droite2);
  
     //CheckY
-    int haut1 = enti1.posy + ErreurHitbox;
-    int bas1 = enti1.posy + H1 - ErreurHitbox;
-    int haut2 = enti2.posy + ErreurHitbox;
-    int bas2 = enti2.posy + H2 - ErreurHitbox;
+    int haut1 = enti1.posy - H1/2 + ErreurHitbox;
+    int bas1  = enti1.posy + H1/2 - ErreurHitbox;
+    int haut2 = enti2.posy - H2/2 + ErreurHitbox;
+    int bas2  = enti2.posy + H2/2 - ErreurHitbox;
     int CheckY = (haut1 <= bas2 && haut1 >= haut2) || (bas1 <= bas2 && bas1 >= haut2);
  
     return CheckX && CheckY;
@@ -85,61 +86,16 @@ void SupprimerEntitesEnCollision(struct liste_entite** Liste1, int L1, int H1, s
  
     if (collision != NULL) {
         // Récupération des entités impliquées
-        struct entite enti1 = collision->enti;
-        struct entite enti2 = collision->suivant->enti;
+        struct entite* enti1 = &collision->enti;
+        struct entite* enti2 = &collision->suivant->enti;
  
-        //Suppression de l'entité 1 de la liste 1
-        
-        //precedant1 garde en memoire l'element precedant de la liste
-        struct liste_entite* precedant1 = NULL;
-        //courant1 garde en memoire l'element courant de la liste
-        struct liste_entite* courant1 = *Liste1;
-        
-        while (courant1 != NULL)
-        {
-            //Comparaison des entites avec memcmp
-            if (memcmp(&courant1->enti, &enti1, sizeof(struct entite)) == 0)
-            {
-                //Si l'element à supprimer est le 1er de la liste
-                if (precedant1 == NULL) 
-                {
-                    *Liste1 = courant1->suivant;
-                } 
-                else 
-                {
-                    precedant1->suivant = courant1->suivant;
-                }
-                free(courant1);
-                break;
-            }
-            
-            precedant1 = courant1;
-            courant1 = courant1->suivant;
-        }
+        // Suppression de l'entité 1 de la liste 1
+        SupprimerEntite(Liste1, enti1);
  
         // Suppression de l'entité 2 de la liste 2
-        struct liste_entite* precedant2 = NULL;
-        struct liste_entite* courant2 = *Liste2;
+        SupprimerEntite(Liste2, enti2);
  
-        while (courant2 != NULL) 
-        {
-            if (memcmp(&courant2->enti, &enti2, sizeof(struct entite)) == 0) 
-            {
-                if (precedant2 == NULL) 
-                {
-                    *Liste2 = courant2->suivant;
-                } else 
-                {
-                    precedant2->suivant = courant2->suivant;
-                }
-                free(courant2);
-                break;
-            }
-            
-            precedant2 = courant2;
-            courant2 = courant2->suivant;
-        }
-        afficherLutin(bouillie, enti2.posx - L1/2 - ErreurHitbox, enti2.posy);
+       afficherLutin(bouillie, enti2->posx - hitboxbouillieL/2 + ErreurHitbox, enti2->posy - hitboxbouillieH/2 + ErreurHitbox);
     }
 }
  
@@ -151,34 +107,32 @@ void Tirer(struct entite joueur, struct liste_entite **pl)
 {
     if (*pl==NULL)
     {
-        ajout_tete(pl,creer_entite(joueur.posx+hitboxcanonL/2-2*ErreurHitbox,joueur.posy,0));
+        ajout_tete(pl,creer_entite(joueur.posx,joueur.posy,-1));
     }
 }
  
  
-    
-    
-
-void DeplacementTire(int tire, struct liste_entite **l) {
-    struct liste_entite *ml = *l;
-    while (ml != NULL) 
+void DeplacementTire(int tire, struct liste_entite** l)
+{
+    struct entite* ml = &(*l)->enti;
+    if (ml != NULL) 
     {
-        if (ml->enti.posy <= 0) 
+        if (ml->posy <= 0) 
         {
-            *l = ml->suivant;
-            afficherLutin(bouillie, ml->enti.posx - hitboxbouillieL / 2, ml->enti.posy);
-            free(ml); 
-            ml = *l;
+            afficherLutin(bouillie, ml->posx - hitboxbouillieL/2 + ErreurHitbox, ml->posy);
+            SupprimerEntite(l, ml);
         }
         else
         {
-            ml->enti.posy -= 5;
-            afficherLutin(tire, ml->enti.posx, ml->enti.posy);
-            ml = ml->suivant;
+            ml->posy -= 5;
+            //Je divise ErreurHitbox par 2 car l'erreur du missile est plus petite que pour les autres images
+            afficherLutin(tire, ml->posx - hitboxmissileL/2 + ErreurHitbox/2, ml->posy - hitboxmissileH/2 + ErreurHitbox/2);
         }
     }
 }
  
+
+
  
 char touche()
 {
@@ -214,3 +168,59 @@ void action(struct entite *joueur, char c, struct liste_entite **tires)
     }
 }
  
+
+
+void MakeBombeDroppable(struct liste_entite* enemies, struct liste_entite** bombes)
+{
+    struct liste_entite* pL = enemies;
+    struct liste_entite* Dropable = NULL;
+    int taille = 0;
+    while (pL != NULL)
+    {
+        if (pL->enti.dropbombe == 1)
+        {
+            ajout_tete(&Dropable,pL->enti);
+            taille += 1;
+        }
+        pL=pL->suivant;
+    }
+    
+    if(Dropable == NULL)
+    {
+        return;
+    }
+        
+    int randomIndex = rand() % taille-1;
+    struct liste_entite* pLDropable = Dropable;
+    
+    for (int i = 0; i <= randomIndex; i++)
+    {
+        pLDropable = pLDropable->suivant;
+    }    
+    ajout_tete(bombes,creer_entite(pLDropable->enti.posx,pLDropable->enti.posy,-1));
+}
+
+
+void DeplacementBombe(int bombe, struct liste_entite** l) 
+{
+    struct liste_entite* ml = *l;
+    struct liste_entite* precedent = NULL;
+    
+    while (ml != NULL) 
+    {
+        if (ml->enti.posy + hitboxbombeH - ErreurHitbox >= Sol) 
+        {
+            struct entite* a_supprimer = &ml->enti;
+            ml = ml->suivant;
+            SupprimerEntite(l, a_supprimer);
+        } 
+        else 
+        {
+            ml->enti.posy += 2;
+            afficherLutin(bombe, ml->enti.posx - hitboxbombeL/2 + ErreurHitbox, ml->enti.posy);
+            precedent = ml;
+            ml = ml->suivant;
+        }
+    }
+}
+
@@ -17,3 +17,7 @@ void SupprimerEntitesEnCollision(struct liste_entite**,int,int,struct liste_enti
 char touche();
  
 void action(struct entite*,char,struct liste_entite**);
+
+void MakeBombeDroppable(struct liste_entite*,struct liste_entite**);
+
+void DeplacementBombe(int,struct liste_entite**);
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include "Liste.h"
  
  
-struct entite creer_entite(int x, int y, int etage)
+struct entite creer_entite(int x, int y, int bombe)
 {
     struct entite e;
-    e.posx=x;
-    e.posy=y;
-    e.etage=etage;
+    e.posx = x;
+    e.posy = y;
+    e.dropbombe = bombe;
     return e;
 }
  
@@ -35,40 +36,29 @@ void imprimer_liste(struct liste_entite *l)
 }
  
  
-void Supprimerentite(struct liste_entite** l, struct liste_entite* suppr)
+
+void SupprimerEntite(struct liste_entite** Liste, struct entite* enti) 
 {
-    //Liste ou Element NULL
-    if(*l == NULL || suppr == NULL) 
-    {
-        return;
-    }
-    
-    //Dernier et Seul élément
-    if (*l == suppr && suppr->suivant == NULL)
-    {
-        *l = NULL;
-        return;
-    }
+    struct liste_entite* courant = *Liste;
+    struct liste_entite* precedent = NULL;
  
-    //1er element
-    if(*l == suppr)
+    while (courant != NULL) 
     {
-        *l=suppr->suivant;
-    }
-
-    else
-    {
-        struct liste_entite* precedent = *l;
-        while(precedent->suivant != NULL && precedent->suivant != suppr)
+        if (memcmp(&courant->enti, enti, sizeof(struct entite)) == 0) 
         {
-            precedent=precedent->suivant;
+            if (precedent == NULL) 
+            {
+                *Liste = courant->suivant;
+            } 
+            else 
+            {
+                precedent->suivant = courant->suivant;
+            }
+            free(courant);
+            break;
         }
-        
-        if(precedent->suivant == NULL)
-        {
-            return ;
-        }
-        precedent->suivant = suppr->suivant;
+        precedent = courant;
+        courant = courant->suivant;
     }
-    free(suppr);
 }
+
 #include <stdio.h>
 #include <stdlib.h>
  
+//dropbombe concerne les entités enemies
+//1 les enemies peuvent drop des bombes, 0 ils ne peuvent pas
+//Celles non concernées vallent -1
 struct entite
 {
     int posx;
     int posy;
-    int etage;
+    int dropbombe;
 };
  
  
@@ -22,4 +25,5 @@ struct entite creer_entite(int,int,int);
  
 void imprimer_liste(struct liste_entite*);
  
-void Supprimerentite(struct liste_entite**, struct liste_entite*);
+void SupprimerEntite(struct liste_entite**,struct entite*);
+
@@ -7,25 +7,33 @@
  
 #define TailleX 500
 #define TailleY 500
+#define ErreurHitbox 2
+#define JoueurX TailleX/2
+#define JoueurY 9*TailleY/10
+    
+struct entite joueur = {JoueurX,JoueurY,-1};
+
+int canon=0;
+int missile=0;
+int sbire=0;
+int bouillie=0;
+int bombe=0;
  
-int canon;
-int missile;
-int sbire;
-int bouillie;
  
-struct entite joueur;
  
 char Nom[15]="Space Invader";
 char input='\0';
  
-int hitboxcanonL;
-int hitboxcanonH;
-int hitboxmissileL;
-int hitboxmissileH;
-int hitboxsbireL;
-int hitboxsbireH;
-int hitboxbouillieL;
-int hitboxbouillieH;
+int hitboxcanonL=0;
+int hitboxcanonH=0;
+int hitboxmissileL=0;
+int hitboxmissileH=0;
+int hitboxsbireL=0;
+int hitboxsbireH=0;
+int hitboxbouillieL=0;
+int hitboxbouillieH=0;
+int hitboxbombeL=0;
+int hitboxbombeH=0;
  
  
  
@@ -35,17 +43,14 @@ void initialiser()
     missile = chargerLutin("../../Lutins/invader_missile.bmp",COULEUR_NOIR);
     sbire = chargerLutin("../../Lutins/invader_monstre1_1.bmp",COULEUR_NOIR);
     bouillie = chargerLutin("../../Lutins/invader_monstre_bouillie.bmp",COULEUR_NOIR);
+    bombe = chargerLutin("../../Lutins/invader_bombe.bmp",COULEUR_NOIR);
  
     tailleLutin(canon,&hitboxcanonL,&hitboxcanonH);
     tailleLutin(missile,&hitboxmissileL,&hitboxmissileH);
     tailleLutin(sbire,&hitboxsbireL,&hitboxsbireH);
     tailleLutin(bouillie,&hitboxbouillieL,&hitboxbouillieH);
+    tailleLutin(bombe,&hitboxbombeL,&hitboxbombeH);
  
-#define JoueurX TailleX/2-hitboxcanonL/2
-#define JoueurY 9*TailleY/10
-    
-    joueur.posx = JoueurX;
-    joueur.posy = JoueurY ;
 }
  
  
@@ -5,6 +5,7 @@ extern int canon;
 extern int missile;
 extern int sbire;
 extern int bouillie;
+extern int bombe;
  
 extern struct entite joueur;
 extern char Nom[15];
@@ -18,6 +19,8 @@ extern int hitboxsbireL;
 extern int hitboxsbireH;
 extern int hitboxbouillieL;
 extern int hitboxbouillieH;
+extern int hitboxbombeL;
+extern int hitboxbombeH;
  
 void initialiser();
 char pagedemarrage();
@@ -22,15 +22,18 @@ int main()
  
     struct liste_entite *enemies = NULL;
     struct liste_entite *tires = NULL;
+    struct liste_entite *bombes = NULL;
  
     char texte[15]="SCORE : ";
     int Score = lutinTexte(texte,COULEUR_BLANC);
  
  
-    LigneSbire(&enemies,3,1);
+    LigneSbire(&enemies,8,3);
     int SensVague=1;
  
-    int compt=0;
+    int compteur=0;
+    int DropAlea=0;
+    int CheckAlea=0;
  
     if (pagedemarrage() != 'j')
     {
@@ -45,27 +48,42 @@ int main()
         rectanglePlein(0,Sol,TailleX,2,COULEUR_VERT);
         afficherLutin(Score,0,Sol+ErreurHitbox);
  
-        afficherLutin(canon,joueur.posx,joueur.posy);
-        
-        if(compt==10)
+        afficherLutin(canon,joueur.posx - hitboxcanonL/2 + ErreurHitbox,joueur.posy);
+
+        if (DropAlea == 0)
         {
-            DeplacementSbire(enemies,&SensVague,1);
-            compt=0;
+            DropAlea = rand() % 31 + 100;
         }
-        AfficherSbire(sbire,enemies);
- 
+        if (CheckAlea == DropAlea)
+        {
+            MakeBombeDroppable(enemies,&bombes);
+            DropAlea=0;
+            CheckAlea=0;
+        }
+        
+        AfficherSbire(sbire,hitboxsbireL,hitboxsbireH,enemies);
+        
         input = touche();
         action(&joueur,input,&tires);
  
+        if (compteur==10)
+        {
+            DeplacementSbire(enemies,&SensVague,1);
+            compteur=0;
+        } 
+
         DeplacementTire(missile,&tires);
  
+        DeplacementBombe(bombe,&bombes);
+        
         SupprimerEntitesEnCollision(&tires,hitboxmissileL,hitboxmissileH,&enemies,hitboxsbireL,hitboxsbireH);
  
         majSurface();
  
         SDL_Delay(20);
  
-        compt+=1;
+        compteur+=1;
+        CheckAlea+=1;
     }
     return 0;
 }
@@ -6,8 +6,9 @@
  
 #define TailleX 500
 #define TailleY 500
+#define ErreurHitbox 2
  
-//sens 1 = Va vers la droite
+//Sens = 1 -> Va vers la droite
 void DeplacementSbire(struct liste_entite *l, int *psens, int speed)
 {
     int ind=0;
@@ -50,28 +51,40 @@ void DeplacementSbire(struct liste_entite *l, int *psens, int speed)
  
  
  
-void AfficherSbire(int lutin,struct liste_entite *l)
-{
-    struct liste_entite *ml=l;
-    while(ml != NULL)
-    {
-        afficherLutin(lutin,ml->enti.posx,ml->enti.posy);
-        ml=ml->suivant;
-    }
-}
-
-
-
 void LigneSbire(struct liste_entite **enemies,int nbr_enemies, int nbr_rangee)
 {
-    for (int j=1; j<=nbr_rangee; j++)
+    for (int j=1; j<= nbr_rangee; j++)
     {
         int compteurY=j*TailleY/10;
         int compteurX=TailleX/nbr_enemies;
+        
         for (int i=0; i<nbr_enemies; i++)
         {
-            ajout_tete(enemies,creer_entite(compteurX,compteurY,j));
-            compteurX +=2*TailleX/(3*nbr_enemies);
+            if (j == nbr_rangee)
+            {
+                ajout_tete(enemies,creer_entite(compteurX,compteurY,1));
+                compteurX +=2*TailleX/(3*nbr_enemies);
+            }
+            else
+            {
+                ajout_tete(enemies,creer_entite(compteurX,compteurY,0));
+                compteurX +=2*TailleX/(3*nbr_enemies);
+            }
         }   
     }
 }
+
+    
+  
+
+void AfficherSbire(int lutin, int L, int H, struct liste_entite *l)
+{
+    struct liste_entite *ml=l;
+    while(ml != NULL)
+    {
+        afficherLutin(lutin,ml->enti.posx - L/2 + ErreurHitbox,ml->enti.posy - H/2 + ErreurHitbox);
+        ml=ml->suivant;
+    }
+}
+
+  
@@ -3,6 +3,6 @@
  
 void DeplacementSbire(struct liste_entite*,int*,int);
  
-void AfficherSbire(int,struct liste_entite*);
-
 void LigneSbire(struct liste_entite**,int,int);
+
+void AfficherSbire(int,int,int,struct liste_entite*);