Commit 1e8c0804c31371af6ac113777efd95d5ee8a2927

Authored by Martin CHAUVELIERE
1 parent 28da2ac2

Derniere correction, à finir demain

Showing 36 changed files with 1508 additions and 0 deletions   Show diff stats
Space Invader/Envahisseurs/Graphique/Lutins/Coeur.bmp 0 → 100644
No preview for this file type
Space Invader/Envahisseurs/Graphique/Lutins/invader_bombe.bmp 0 → 100644
No preview for this file type
Space Invader/Envahisseurs/Graphique/Lutins/invader_bouclier.bmp 0 → 100644
No preview for this file type
Space Invader/Envahisseurs/Graphique/Lutins/invader_canon.bmp 0 → 100644
No preview for this file type
Space Invader/Envahisseurs/Graphique/Lutins/invader_canon_ferraille.bmp 0 → 100644
No preview for this file type
Space Invader/Envahisseurs/Graphique/Lutins/invader_missile.bmp 0 → 100644
No preview for this file type
Space Invader/Envahisseurs/Graphique/Lutins/invader_monstre1_1.bmp 0 → 100644
No preview for this file type
Space Invader/Envahisseurs/Graphique/Lutins/invader_monstre1_2.bmp 0 → 100644
No preview for this file type
Space Invader/Envahisseurs/Graphique/Lutins/invader_monstre2_1.bmp 0 → 100644
No preview for this file type
Space Invader/Envahisseurs/Graphique/Lutins/invader_monstre2_2.bmp 0 → 100644
No preview for this file type
Space Invader/Envahisseurs/Graphique/Lutins/invader_monstre3_1.bmp 0 → 100644
No preview for this file type
Space Invader/Envahisseurs/Graphique/Lutins/invader_monstre3_2.bmp 0 → 100644
No preview for this file type
Space Invader/Envahisseurs/Graphique/Lutins/invader_monstre_bouillie.bmp 0 → 100644
No preview for this file type
Space Invader/Envahisseurs/Graphique/Lutins/invader_ovni.bmp 0 → 100644
No preview for this file type
Space Invader/Envahisseurs/Graphique/Lutins/millepatte_champi.bmp 0 → 100644
No preview for this file type
Space Invader/Envahisseurs/Graphique/Lutins/millepatte_corps_bas.bmp 0 → 100644
No preview for this file type
Space Invader/Envahisseurs/Graphique/Lutins/millepatte_corps_droite.bmp 0 → 100644
No preview for this file type
Space Invader/Envahisseurs/Graphique/Lutins/millepatte_corps_gauche.bmp 0 → 100644
No preview for this file type
Space Invader/Envahisseurs/Graphique/Lutins/millepatte_corps_haut.bmp 0 → 100644
No preview for this file type
Space Invader/Envahisseurs/Graphique/Lutins/millepatte_tete_bas.bmp 0 → 100644
No preview for this file type
Space Invader/Envahisseurs/Graphique/Lutins/millepatte_tete_droite.bmp 0 → 100644
No preview for this file type
Space Invader/Envahisseurs/Graphique/Lutins/millepatte_tete_gauche.bmp 0 → 100644
No preview for this file type
Space Invader/Envahisseurs/Graphique/Lutins/millepatte_tete_haut.bmp 0 → 100644
No preview for this file type
Space Invader/Envahisseurs/Graphique/src/Graphique/Makefile 0 → 100644
@@ -0,0 +1,29 @@ @@ -0,0 +1,29 @@
  1 +#
  2 +# Makefile pour la bibliotheque graphique
  3 +#
  4 +
  5 +SOURCES = $(wildcard *.c)
  6 +OBJETS = $(SOURCES:.c=.o)
  7 +CIBLE = libgraph.a
  8 +
  9 +#
  10 +# Nom de la cible principale
  11 +#
  12 +
  13 +all: $(CIBLE)
  14 +
  15 +#
  16 +# Cible de nettoyage
  17 +#
  18 +
  19 +clean:
  20 + rm -f core *.o $(CIBLE)
  21 +
  22 +#
  23 +# Dependances pour la bibliotheque
  24 +#
  25 +
  26 +$(CIBLE): $(OBJETS)
  27 + $(AR) rs $@ $?
  28 +
  29 +$(CIBLE:.a=).o: $(CIBLE:.a=).c $(CIBLE:.a=).h
Space Invader/Envahisseurs/Graphique/src/Graphique/libgraph.c 0 → 100644
@@ -0,0 +1,239 @@ @@ -0,0 +1,239 @@
  1 +/**** Bibliotheque graphique ****/
  2 +
  3 +/** Fichiers d'inclusion **/
  4 +
  5 +#include <SDL/SDL.h>
  6 +#include <SDL/SDL_ttf.h>
  7 +#include "libgraph.h"
  8 +
  9 +/** Types **/
  10 +
  11 +typedef struct
  12 +{
  13 + int r, v, b;
  14 +} couleur;
  15 +
  16 +/** Constantes **/
  17 +
  18 +#define BITS_PAR_PIXEL 32
  19 +#define TAILLE_POLICE 20
  20 +
  21 +static const couleur couleurs[] = { { 255, 255, 255 }, { 0, 0, 0 }, { 255, 0, 0 },
  22 + { 0, 255, 0 }, { 0, 0, 255 }, { 255, 105, 180 },
  23 + { 150, 150, 150 }, { -1, -1, -1 } };
  24 +
  25 +static const char policeDefaut[]="/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf";
  26 +
  27 +/** Variables globales **/
  28 +
  29 +static SDL_Surface *surface;
  30 +TTF_Font* police;
  31 +
  32 +/** Fonctions **/
  33 +
  34 +void choisirPolice(const char *chemin, int taille){
  35 + police=TTF_OpenFont(chemin, taille);
  36 +}
  37 +
  38 +void initialiserTexte() {
  39 + TTF_Init();
  40 + choisirPolice(policeDefaut, TAILLE_POLICE);
  41 +}
  42 +
  43 +/* Initialisation de la surface dessinable */
  44 +unsigned char creerSurface (int largeur, int hauteur, char *titre)
  45 +{
  46 + SDL_Init (SDL_INIT_VIDEO);
  47 + SDL_WM_SetCaption (titre, titre);
  48 + surface = SDL_SetVideoMode (largeur, hauteur, BITS_PAR_PIXEL, SDL_DOUBLEBUF);
  49 + initialiserTexte();
  50 +
  51 + return (surface != NULL && police != NULL);
  52 +}
  53 +
  54 +/* Fermeture de la surface dessinable */
  55 +
  56 +void fermerSurface (void)
  57 +{
  58 + if (surface != NULL) SDL_FreeSurface (surface);
  59 + if (police != NULL) TTF_CloseFont(police);
  60 + TTF_Quit();
  61 + SDL_Quit ();
  62 +}
  63 +
  64 +/* Creation d'une couleur */
  65 +
  66 +static int creerCouleur (int ncouleur)
  67 +{
  68 + couleur c = couleurs[ncouleur];
  69 + return SDL_MapRGB (surface->format, c.r, c.v, c.b);
  70 +}
  71 +
  72 +/* Dessin d'un rectangle plein */
  73 +
  74 +void rectanglePlein (int x, int y, int l, int h, int c)
  75 +{
  76 + SDL_Rect rectangle = { x, y, l, h };
  77 + SDL_FillRect (surface, &rectangle, creerCouleur (c));
  78 + // SDL_Flip(surface);
  79 +}
  80 +
  81 +/* Manipulation de lutins */
  82 +
  83 +static SDL_Surface *lutins[MAX_LUTINS];
  84 +static int lutins_nb = 0;
  85 +
  86 +int lutinTexte(char* texte, int couleurTexte) {
  87 + couleur c=couleurs[couleurTexte];
  88 + SDL_Color couleur={c.r, c.v, c.b};
  89 + SDL_Surface* lutin=TTF_RenderText_Solid(police, texte, couleur);
  90 + if (lutin != NULL)
  91 + {
  92 + lutins[lutins_nb++] = lutin;
  93 + return lutins_nb - 1;
  94 + }
  95 + return -1;
  96 +}
  97 +
  98 +static void configurerLutin (SDL_Surface *lutin, int ncouleur)
  99 +{
  100 + couleur c = couleurs[ncouleur];
  101 + int fond = SDL_MapRGB (lutin->format, c.r, c.v, c.b);
  102 + SDL_SetColorKey (lutin, SDL_SRCCOLORKEY | SDL_RLEACCEL, fond);
  103 +}
  104 +
  105 +int chargerLutin (char *fichier, int couleur)
  106 +{
  107 + if (lutins_nb >= MAX_LUTINS) return -2;
  108 + SDL_Surface *lutin = SDL_LoadBMP (fichier);
  109 + if (lutin != NULL)
  110 + {
  111 + lutins[lutins_nb++] = lutin;
  112 + if (couleur >= 0) configurerLutin (lutin, couleur);
  113 + return lutins_nb - 1;
  114 + }
  115 + return -1;
  116 +}
  117 +
  118 +void afficherLutin (int lutin, int x, int y)
  119 +{
  120 + SDL_Rect position;
  121 + position.x = x;
  122 + position.y = y;
  123 + SDL_BlitSurface (lutins[lutin], NULL, surface, &position);
  124 +}
  125 +
  126 +int creerLutin (int x, int y, int largeur, int hauteur, int couleur)
  127 +{
  128 + if (lutins_nb >= MAX_LUTINS) return -2;
  129 + int rmask, gmask, bmask, amask;
  130 +#if SDL_BYTEORDER == SDL_BIG_ENDIAN
  131 + rmask = 0xff000000;
  132 + gmask = 0x00ff0000;
  133 + bmask = 0x0000ff00;
  134 + amask = 0x000000ff;
  135 +#else
  136 + rmask = 0x000000ff;
  137 + gmask = 0x0000ff00;
  138 + bmask = 0x00ff0000;
  139 + amask = 0xff000000;
  140 +#endif
  141 + if (couleur < 0) amask = 0x00000000;
  142 + SDL_Surface *lutin =
  143 + SDL_CreateRGBSurface (0, largeur, hauteur, BITS_PAR_PIXEL, rmask, gmask, bmask, amask);
  144 + SDL_Rect fenetre;
  145 + fenetre.x = x;
  146 + fenetre.y = y;
  147 + fenetre.h = hauteur;
  148 + fenetre.w = largeur;
  149 + SDL_BlitSurface (surface, &fenetre, lutin, NULL);
  150 + lutins[lutins_nb++] = lutin;
  151 + if (couleur >= 0) configurerLutin (lutin, couleur);
  152 + return lutins_nb - 1;
  153 +}
  154 +
  155 +void tailleLutin (int lutin, int *largeur, int *hauteur)
  156 +{
  157 + *largeur = lutins[lutin]->w;
  158 + *hauteur = lutins[lutin]->h;
  159 +}
  160 +
  161 +int sauverLutin (int lutin, char *nom) { return SDL_SaveBMP (lutins[lutin], nom); }
  162 +
  163 +/* Manipulation de copie de surface en BMP */
  164 +
  165 +int sauverSurface (char *fichier) { return SDL_SaveBMP (surface, fichier); }
  166 +
  167 +unsigned char chargerSurface (char *fichier)
  168 +{
  169 + SDL_Surface *image = SDL_LoadBMP (fichier);
  170 + if (image != NULL)
  171 + {
  172 + SDL_BlitSurface (image, NULL, surface, NULL);
  173 + SDL_Flip (surface);
  174 + }
  175 + return (image != NULL);
  176 +}
  177 +
  178 +void majSurface (void) { SDL_Flip (surface); }
  179 +
  180 +/* Trouver la couleur d'un pixel */
  181 +
  182 +int couleurPixel (int x, int y)
  183 +{
  184 + int bpp = surface->format->BytesPerPixel;
  185 + Uint32 *p = (Uint32 *)(surface->pixels + y * surface->pitch + x * bpp);
  186 + Uint8 r, v, b;
  187 + SDL_GetRGB (*p, surface->format, &r, &v, &b);
  188 + int i = 0;
  189 + while (1)
  190 + {
  191 + if (couleurs[i].r < 0) break;
  192 + if (r == couleurs[i].r && v == couleurs[i].v && b == couleurs[i].b) break;
  193 + i++;
  194 + }
  195 + if (couleurs[i].r < 0)
  196 + return -1;
  197 + else
  198 + return i;
  199 +}
  200 +
  201 +/* Fonction de traitement des événements */
  202 +
  203 +void lireEvenement (evenement *evt, char *touche, void **detail)
  204 +{
  205 + static SDL_keysym _detail;
  206 + SDL_Event event;
  207 + while (SDL_PollEvent (&event))
  208 + {
  209 + if (event.type == SDL_QUIT) *evt = quitter;
  210 + if (event.type == SDL_KEYDOWN || event.type == SDL_KEYUP)
  211 + {
  212 + *evt = (event.type == SDL_KEYDOWN) ? toucheBas : toucheHaut;
  213 + char *nom = SDL_GetKeyName (event.key.keysym.sym);
  214 + if (strlen (nom) == 1 && nom[0] >= 32 && nom[0] < 128)
  215 + *touche = nom[0];
  216 + else
  217 + *touche = 0;
  218 + if (detail != NULL)
  219 + {
  220 + _detail = event.key.keysym;
  221 + *detail = &_detail;
  222 + }
  223 + break;
  224 + }
  225 + }
  226 +}
  227 +
  228 +void attendreEvenement (void)
  229 +{
  230 + SDL_Event event;
  231 + while (SDL_WaitEvent (&event)) switch (event.type)
  232 + {
  233 + case SDL_QUIT:
  234 + exit (0);
  235 + case SDL_KEYDOWN:
  236 + case SDL_MOUSEBUTTONDOWN:
  237 + return;
  238 + }
  239 +}
Space Invader/Envahisseurs/Graphique/src/Graphique/libgraph.h 0 → 100644
@@ -0,0 +1,156 @@ @@ -0,0 +1,156 @@
  1 +/**** Bibliotheque graphique (definitions) ****/
  2 +
  3 +/** Constantes **/
  4 +
  5 +#define COULEUR_BLANC 0
  6 +#define COULEUR_NOIR 1
  7 +#define COULEUR_ROUGE 2
  8 +#define COULEUR_VERT 3
  9 +#define COULEUR_BLEU 4
  10 +#define COULEUR_ROSE 5
  11 +#define COULEUR_GRIS 6
  12 +
  13 +#define MAX_LUTINS 16
  14 +
  15 +typedef enum {toucheBas, toucheHaut, quitter} evenement;
  16 +
  17 +/** Prototypes **/
  18 +
  19 +/**
  20 + * @brief cree une fenetre 2D
  21 + *
  22 + * @param largeur en pixels de la fenetre
  23 + * @param hauteur en pixels de la fenetre
  24 + * @param titre de la fenetre (chaine de caractere)
  25 + */
  26 +unsigned char creerSurface (int largeur, int hauteur, char *titre);
  27 +
  28 +/**
  29 + * @brief permet de charger un fichier image au format bmp (bitmap)
  30 + *
  31 + * @param fichier nom du fichier
  32 + */
  33 +unsigned char chargerSurface (char *fichier);
  34 +
  35 +
  36 +/**
  37 + * @brief permet de sauvegarder une surface en image (format bmp)
  38 + *
  39 + * @param fichier nom du fichier
  40 + * @return 0 si OK, valeur negative sinon
  41 + */
  42 +int sauverSurface (char *fichier);
  43 +
  44 +/**
  45 + * @brief met a jour la surface d'affichage
  46 + */
  47 +void majSurface (void);
  48 +
  49 +
  50 +/**
  51 + * @brief libere la surface d'affichage
  52 + * a faire lors de la fermeture
  53 + * du programme
  54 + */
  55 +void fermerSurface (void);
  56 +
  57 +/**
  58 + * @brief choisit la police de caractères à utiliser pour afficher du texte
  59 + * @param chemin nom du fichier de police (format .ttf, voir /usr/share/fonts/truetype)
  60 + * @param taille taille de la police
  61 + */
  62 +void choisirPolice(const char *chemin, int taille);
  63 +
  64 +/**
  65 + * @brief dessine un rectange de taille (l,h) aux coordonnêes
  66 + * (x,y) et de couleur c
  67 + *
  68 + * @param x 0 <= x <= l_surface
  69 + * @param y 0 <= y <= h_surface
  70 + * @param l largeur en pixels
  71 + * @param h longueur en pixels
  72 + * @param c indice de couleur voir variable couleurs dans le fichier .c
  73 + */
  74 +void rectanglePlein (int x, int y, int l, int h, int c);
  75 +
  76 +
  77 +/**
  78 + * @brief permet de determiner l'indice du tableau de couleur du
  79 + * pixel aux coordonnees (x,y)
  80 + *
  81 + * @param x 0 <= x <= l_surface
  82 + * @param y 0 <= y <= h_surface
  83 + * @return indice de couleur voire variable couleurs dans le fichier .c
  84 + */
  85 +int couleurPixel (int x, int y);
  86 +
  87 +/**
  88 + * @brief crée un lutin à partir d'un texte
  89 + *
  90 + * @param texte le texte
  91 + * @param couleur indice de couleur du texte
  92 + * @return numero de lutin dans le tableau dynamique de lutin (< MAX_LUTINS)
  93 + */
  94 +int lutinTexte(char *texte, int couleur);
  95 +
  96 +/**
  97 + * @brief charge un lutin à partir du fichier
  98 + *
  99 + * @param fichier image bitmap du lutin à charger
  100 + * @param couleur indice de couleurs à charger
  101 + * @return numero de lutin dans le tableau dynamique de lutin (< MAX_LUTINS)
  102 + */
  103 +int chargerLutin (char *fichier, int couleur);
  104 +
  105 +/**
  106 + * @brief afficher un lutin aux coordonnées (x,y)
  107 + *
  108 + * @param lutin numero du lutin à afficher (< MAX_LUTINS)
  109 + * @param x abscisse de départ
  110 + * @param y ordonnée de départ
  111 + */
  112 +void afficherLutin (int lutin, int x, int y);
  113 +
  114 +/**
  115 + * @brief creer un lutin de taille (l,h) aux coordonnées (x,y)
  116 + *
  117 + * @param x abscisse de départ
  118 + * @param y ordonnée de départ
  119 + * @param largeur largeur du lutin
  120 + * @param hauteur hauteur du lutin
  121 + * @param couleur indice de couleur à partir du tableau _couleurs_
  122 + * @return indice du lutin dans le tableau global (< MAX_LUTINS)
  123 + */
  124 +int creerLutin (int x, int y, int largeur, int hauteur, int couleur);
  125 +
  126 +/**
  127 + * @brief sauvegarde un lutin dans un fichier
  128 + *
  129 + * @param lutin numero de lutin à sauvegarder (< MAX_LUTINS)
  130 + * @param nom fichier pour la sauvegarde
  131 + * @return 0 si OK valeur négative sinon
  132 + */
  133 +int sauverLutin (int lutin, char *nom);
  134 +
  135 +/**
  136 + * @brief calcule la taille (largeur,hauteur) d'un lutin
  137 + *
  138 + * @param lutin index du lutin (< MAX_LUTINS)
  139 + * @param largeur pointeur sur la largeur
  140 + * @param hauteur pointeur sur la hauteur
  141 + */
  142 +void tailleLutin (int lutin, int *largeur, int *hauteur);
  143 +
  144 +/**
  145 + * @brief lire une touche au clavier
  146 + *
  147 + * @param evt pointeur sur evenement
  148 + * @param touche pointeur sur la touche pressée
  149 + * @param detail NULL ou keysim
  150 + */
  151 +void lireEvenement (evenement *evt, char *touche, void **detail);
  152 +
  153 +/**
  154 + * @brief attente d'un evenement bouton, souris, fin de programme
  155 + */
  156 +void attendreEvenement (void);
Space Invader/Envahisseurs/Graphique/src/Interactif/Interactif.c 0 → 100644
@@ -0,0 +1,361 @@ @@ -0,0 +1,361 @@
  1 +#include <stdio.h>
  2 +#include <stdlib.h>
  3 +#include <string.h>
  4 +#include "../Graphique/libgraph.h"
  5 +#include "../ListeC/Liste.h"
  6 +#include "Interactif.h"
  7 +#include "../Main/init.h"
  8 +
  9 +#define TailleX 500
  10 +#define TailleY 500
  11 +#define Sol 475
  12 +#define ErreurHitbox 2
  13 +#define ValeurDeplacementTire 5
  14 +#define ValeurDeplacementJoueur 3
  15 +#define ValeurDeplacementBombe 2
  16 +#define TailleX9_10 9 * TailleX / 10
  17 +#define TailleX1_10 TailleX / 10
  18 +
  19 +int CheckCollisionEntiteEntite (struct entite entite1,
  20 + int L1,
  21 + int H1,
  22 + struct entite entite2,
  23 + int L2,
  24 + int H2)
  25 +{
  26 + //CheckX
  27 + int gauche1 = entite1.posx - L1/2 + ErreurHitbox;
  28 + int droite1 = entite1.posx + L1/2 - ErreurHitbox;
  29 + int gauche2 = entite2.posx - L2/2 + ErreurHitbox;
  30 + int droite2 = entite2.posx + L2/2 - ErreurHitbox;
  31 + //Tout les cas possibles de collision
  32 + int CheckX = (gauche1 >= gauche2 && gauche1 <= droite2) ||
  33 + (droite1 >= gauche2 && droite1 <= droite2) ||
  34 + (gauche1 >= gauche2 && droite1 <= droite2) ||
  35 + (gauche2 >= gauche1 && droite2 <= droite1);
  36 +
  37 + //CheckY
  38 + int haut1 = entite1.posy - H1/2 + ErreurHitbox;
  39 + int bas1 = entite1.posy + H1/2 - ErreurHitbox;
  40 + int haut2 = entite2.posy - H2/2 + ErreurHitbox;
  41 + int bas2 = entite2.posy + H2/2 - ErreurHitbox;
  42 + int CheckY = (haut1 <= bas2 && haut1 >= haut2) ||
  43 + (bas1 <= bas2 && bas1 >= haut2) ||
  44 + (haut1 <= haut2 && bas1 >= bas2) ||
  45 + (haut2 <= haut1 && bas2 >= bas1);
  46 +
  47 +
  48 + return CheckX && CheckY;
  49 +}
  50 +
  51 +//La fonction renvoie l'entite de la Liste1 si il y a collision
  52 +struct entite* CheckCollisionListeEntite (struct liste_entite* Liste1,
  53 + int L1,
  54 + int H1,
  55 + struct entite entite2,
  56 + int L2,
  57 + int H2)
  58 +{
  59 +
  60 + struct liste_entite *pListe1 = Liste1;
  61 + while (pListe1 != NULL)
  62 + {
  63 +
  64 + if(CheckCollisionEntiteEntite (pListe1->entite,
  65 + L1,
  66 + H1,
  67 + entite2,
  68 + L2,
  69 + H2) == 1)
  70 + {
  71 + return &pListe1->entite;
  72 + }
  73 +
  74 + pListe1 = pListe1->suivant;
  75 + }
  76 + return NULL;
  77 +}
  78 +
  79 +
  80 +
  81 +//La fonction renvoie une liste d'entite avec les deux entites à supprimer si il y a collision
  82 +struct liste_entite* CheckCollisionListeListe (struct liste_entite* Liste1,
  83 + int L1,
  84 + int H1,
  85 + struct liste_entite* Liste2,
  86 + int L2,
  87 + int H2)
  88 +{
  89 +
  90 + struct liste_entite *pListe2 = Liste2;
  91 + while (pListe2 != NULL)
  92 + {
  93 +
  94 + struct entite* collision = CheckCollisionListeEntite (Liste1,
  95 + L1,
  96 + H1,
  97 + pListe2->entite,
  98 + L2,
  99 + H2);
  100 + if (collision != NULL)
  101 + {
  102 + // Création des structures pour les deux entités
  103 + struct liste_entite* Entite1 = malloc(sizeof(struct liste_entite));
  104 + struct liste_entite* Entite2 = malloc(sizeof(struct liste_entite));
  105 +
  106 + // Remplissage des structure avec les entités correspondantes
  107 + Entite1->entite = *collision;
  108 + Entite2->entite = pListe2->entite;
  109 +
  110 + // Relier les structures entre elles
  111 + Entite1->suivant = Entite2;
  112 + Entite2->suivant = NULL;
  113 +
  114 + return Entite1;
  115 + }
  116 +
  117 + else
  118 + pListe2 = pListe2->suivant;
  119 + }
  120 +
  121 + return NULL;
  122 +}
  123 +
  124 +//Tire un missile, il ne peux y en avoir que un à la fois
  125 +void Tirer (struct entite joueur,
  126 + struct liste_entite** pl)
  127 +{
  128 + if (*pl == NULL)
  129 + {
  130 + ajout_tete(pl,
  131 + creer_entite(joueur.posx,
  132 + joueur.posy,
  133 + -1));
  134 + }
  135 +}
  136 +
  137 +
  138 +void DeplacementTire(struct liste_entite** Liste)
  139 +{
  140 + struct entite* Entite = &(*Liste)->entite;
  141 + if (Entite != NULL)
  142 + {
  143 +
  144 + if (Entite->posy <= 0)
  145 + {
  146 + afficherLutin(bouillie,
  147 + Entite->posx - hitboxbouillieL/2 + ErreurHitbox,
  148 + Entite->posy);
  149 + SupprimerEntite(Liste, Entite);
  150 + }
  151 +
  152 + else
  153 + {
  154 + Entite->posy -= ValeurDeplacementTire;
  155 + //Je divise ErreurHitbox par 2 car l'erreur du missile est plus petite que pour les autres images
  156 + afficherLutin(missile,
  157 + Entite->posx - hitboxmissileL/2 + ErreurHitbox/2,
  158 + Entite->posy - hitboxmissileH/2 + ErreurHitbox/2);
  159 + }
  160 + }
  161 +}
  162 +
  163 +
  164 +
  165 +//La fonction renvoie la touche préssée
  166 +char touche()
  167 +{
  168 + char touche;
  169 + evenement even;
  170 + lireEvenement (&even,&touche,NULL);
  171 + return touche;
  172 +}
  173 +
  174 +
  175 +//Fais une action soit au joueur soit aux tires selon la touche préssée
  176 +void action(struct entite* joueur,
  177 + char c,
  178 + struct liste_entite** tires)
  179 +{
  180 + switch (c)
  181 + {
  182 + case 'd':
  183 + if (joueur->posx <= TailleX9_10)
  184 + {
  185 + joueur->posx += ValeurDeplacementJoueur;
  186 + }
  187 + break;
  188 + case 'q':
  189 + if (joueur->posx >= TailleX1_10)
  190 + {
  191 + joueur->posx -= ValeurDeplacementJoueur;
  192 + }
  193 + break;
  194 + case 't':
  195 + Tirer(*joueur,
  196 + tires);
  197 + break;
  198 + default:
  199 + break;
  200 + }
  201 +}
  202 +
  203 +//La fonction crée une liste de tout les enemies pouvant drop des bombes
  204 +//Puis ajoute à la liste bombe, une bombe random provenant d'un des enemies pouvant drop des bombes
  205 +void MakeBombeDroppable (struct liste_entite* enemies,
  206 + struct liste_entite** bombes)
  207 +{
  208 +
  209 + struct liste_entite* pListe = enemies;
  210 + struct liste_entite* Dropable = NULL;
  211 + int taille = 0;
  212 +
  213 + while (pListe != NULL)
  214 + {
  215 +
  216 + if (pListe->entite.dropbombe == 1)
  217 + {
  218 + ajout_tete(&Dropable,pListe->entite);
  219 + taille += 1;
  220 + }
  221 +
  222 + pListe = pListe->suivant;
  223 + }
  224 +
  225 + if(Dropable == NULL)
  226 + {
  227 + return;
  228 + }
  229 +
  230 + int randomIndex = rand() % taille-1;
  231 + struct liste_entite* pDropable = Dropable;
  232 +
  233 + for (int i = 0; i <= randomIndex; i++)
  234 + {
  235 + pDropable = pDropable->suivant;
  236 + }
  237 +
  238 + ajout_tete(bombes,
  239 + creer_entite(pDropable->entite.posx,
  240 + pDropable->entite.posy,
  241 + -1));
  242 +}
  243 +
  244 +//
  245 +void DeplacementBombe(struct liste_entite** Liste)
  246 +{
  247 + struct liste_entite* pListe = *Liste;
  248 + struct liste_entite* precedent = NULL;
  249 +
  250 + while (pListe != NULL)
  251 + {
  252 +
  253 + if (pListe->entite.posy + hitboxbombeH/2 - ErreurHitbox >= Sol)
  254 + {
  255 + struct entite* a_supprimer = &pListe->entite;
  256 +
  257 + pListe = pListe->suivant;
  258 + SupprimerEntite(Liste,a_supprimer);
  259 + }
  260 +
  261 + else
  262 + {
  263 + pListe->entite.posy += ValeurDeplacementBombe;
  264 + afficherLutin(bombe,
  265 + pListe->entite.posx - hitboxbombeL/2 + ErreurHitbox,
  266 + pListe->entite.posy - hitboxbombeH/2 + ErreurHitbox);
  267 + precedent = pListe;
  268 + pListe = pListe->suivant;
  269 + }
  270 + }
  271 +}
  272 +
  273 +
  274 +void NouveauDroppeurBombe (struct liste_entite** liste,
  275 + struct entite* entite)
  276 +{
  277 +
  278 + int posx = entite->posx;
  279 + int posy = entite->posy;
  280 + struct liste_entite* pListe = *liste;
  281 + struct entite* entite_basse = NULL;
  282 +
  283 + // On parcourt la liste et on cherche l'entité la plus basse ayant la même position x
  284 + while (pListe != NULL)
  285 + {
  286 +
  287 + if (pListe->entite.posy != posy)
  288 + {
  289 +
  290 + if (pListe->entite.posx == posx &&
  291 + entite_basse == NULL)
  292 + {
  293 + entite_basse = &pListe->entite;
  294 + }
  295 +
  296 + else if (pListe->entite.posx == posx &&
  297 + pListe->entite.posy > entite_basse->posy)
  298 + {
  299 + entite_basse = &pListe->entite;
  300 + }
  301 + }
  302 +
  303 + pListe = pListe->suivant;
  304 + }
  305 +
  306 + // Si aucune entité n'est située plus bas que l'entité en question, on ne peut pas dropper la bombe
  307 + if (entite_basse == NULL)
  308 + {
  309 + return;
  310 + }
  311 +
  312 + entite_basse->dropbombe = 1;
  313 +}
  314 +
  315 +
  316 +
  317 +
  318 +int SupprimerEntitesEnCollision (struct liste_entite** Liste1,
  319 + int L1,
  320 + int H1,
  321 + struct liste_entite** Liste2,
  322 + int L2,
  323 + int H2)
  324 +{
  325 +
  326 + struct liste_entite* collision = CheckCollisionListeListe(*Liste1,
  327 + L1,
  328 + H1,
  329 + *Liste2,
  330 + L2,
  331 + H2);
  332 + if (collision != NULL)
  333 + {
  334 + // Récupération des entités impliquées
  335 + struct entite* Entite1 = &collision->entite;
  336 + struct entite* Entite2 = &collision->suivant->entite;
  337 +
  338 + if (Entite1->dropbombe == 1)
  339 + {
  340 + NouveauDroppeurBombe(Liste1,Entite1);
  341 + }
  342 +
  343 + if (Entite2->dropbombe == 1)
  344 + {
  345 + NouveauDroppeurBombe(Liste2,Entite2);
  346 + }
  347 +
  348 + // Suppression de l'entité 1 de la liste 1
  349 + SupprimerEntite(Liste1, Entite1);
  350 + // Suppression de l'entité 2 de la liste 2
  351 + SupprimerEntite(Liste2, Entite2);
  352 +
  353 + afficherLutin(bouillie,
  354 + Entite2->posx - hitboxbouillieL/2 + ErreurHitbox,
  355 + Entite2->posy - hitboxbouillieH/2 + ErreurHitbox);
  356 + return 1;
  357 + }
  358 + return 0;
  359 +}
  360 +
  361 +
Space Invader/Envahisseurs/Graphique/src/Interactif/Interactif.h 0 → 100644
@@ -0,0 +1,50 @@ @@ -0,0 +1,50 @@
  1 +#include <stdio.h>
  2 +#include <stdlib.h>
  3 +
  4 +
  5 +int CheckCollisionEntiteEntite (struct entite entite1,
  6 + int L1,
  7 + int H1,
  8 + struct entite entite2,
  9 + int L2,
  10 + int H2);
  11 +
  12 +struct entite* CheckCollisionListeEntite (struct liste_entite* Liste1,
  13 + int L1,
  14 + int H1,
  15 + struct entite entite2,
  16 + int L2,
  17 + int H2);
  18 +
  19 +struct liste_entite* CheckCollisionListeListe (struct liste_entite* Liste1,
  20 + int L1,
  21 + int H1,
  22 + struct liste_entite* Liste2,
  23 + int L2,
  24 + int H2);
  25 +
  26 +void Tirer (struct entite joueur,
  27 + struct liste_entite** pl);
  28 +
  29 +void DeplacementTire(struct liste_entite** Liste);
  30 +
  31 +char touche();
  32 +
  33 +void action(struct entite* joueur,
  34 + char c,
  35 + struct liste_entite** tires);
  36 +
  37 +void MakeBombeDroppable (struct liste_entite* enemies,
  38 + struct liste_entite** bombes);
  39 +
  40 +void DeplacementBombe(struct liste_entite** Liste) ;
  41 +
  42 +void NouveauDroppeurBombe (struct liste_entite** liste,
  43 + struct entite* entite);
  44 +
  45 +int SupprimerEntitesEnCollision (struct liste_entite** Liste1,
  46 + int L1,
  47 + int H1,
  48 + struct liste_entite** Liste2,
  49 + int L2,
  50 + int H2);
Space Invader/Envahisseurs/Graphique/src/ListeC/Liste.c 0 → 100644
@@ -0,0 +1,69 @@ @@ -0,0 +1,69 @@
  1 +#include <stdio.h>
  2 +#include <stdlib.h>
  3 +#include <string.h>
  4 +
  5 +#include "Liste.h"
  6 +
  7 +//Crée une entité
  8 +struct entite creer_entite (int x,
  9 + int y,
  10 + int bombe)
  11 +{
  12 + struct entite e;
  13 +
  14 + e.posx = x;
  15 + e.posy = y;
  16 + e.dropbombe = bombe;
  17 +
  18 + return e;
  19 +}
  20 +
  21 +
  22 +//Ajout en tete une entité dans une liste
  23 +void ajout_tete (struct liste_entite** Liste,
  24 + struct entite x )
  25 +{
  26 + struct liste_entite *Listetmp=NULL;
  27 +
  28 + Listetmp = malloc(sizeof(struct liste_entite));
  29 + Listetmp->entite = x;
  30 + Listetmp->suivant = *Liste;
  31 +
  32 + *Liste = Listetmp;
  33 +}
  34 +
  35 +
  36 +//Supprime une entite d'une liste
  37 +void SupprimerEntite (struct liste_entite** Liste,
  38 + struct entite* entite)
  39 +{
  40 + struct liste_entite* courant = *Liste;
  41 + struct liste_entite* precedent = NULL;
  42 +
  43 + while (courant != NULL)
  44 + {
  45 +
  46 + if (memcmp (&courant->entite,
  47 + entite,
  48 + sizeof(struct entite)) == 0)
  49 + {
  50 +
  51 + if (precedent == NULL)
  52 + {
  53 + *Liste = courant->suivant;
  54 + }
  55 +
  56 + else
  57 + {
  58 + precedent->suivant = courant->suivant;
  59 + }
  60 +
  61 + free(courant);
  62 + break;
  63 + }
  64 +
  65 + precedent = courant;
  66 + courant = courant->suivant;
  67 + }
  68 +}
  69 +
Space Invader/Envahisseurs/Graphique/src/ListeC/Liste.h 0 → 100644
@@ -0,0 +1,31 @@ @@ -0,0 +1,31 @@
  1 +#include <stdio.h>
  2 +#include <stdlib.h>
  3 +
  4 +//dropbombe concerne les entités enemies
  5 +//1 les enemies peuvent drop des bombes, 0 ils ne peuvent pas
  6 +//Les entites non concernées vallent ont un dropbombe = -1
  7 +struct entite
  8 +{
  9 + int posx;
  10 + int posy;
  11 + int dropbombe;
  12 +};
  13 +
  14 +
  15 +struct liste_entite
  16 +{
  17 + struct entite entite;
  18 + struct liste_entite *suivant;
  19 +};
  20 +
  21 +
  22 +struct entite creer_entite (int x,
  23 + int y,
  24 + int bombe);
  25 +
  26 +void ajout_tete (struct liste_entite** Liste,
  27 + struct entite x );
  28 +
  29 +void SupprimerEntite (struct liste_entite** Liste,
  30 + struct entite* entite);
  31 +
Space Invader/Envahisseurs/Graphique/src/Main/Makefile 0 → 100644
@@ -0,0 +1,34 @@ @@ -0,0 +1,34 @@
  1 +CC=clang
  2 +TARGET=exec
  3 +CFLAGS=-g -W -Wall -Wextra
  4 +LDFLAGS=-I Graphique -l graph -L ../Graphique -l SDL -l SDL_ttf
  5 +
  6 +default: $(TARGET)
  7 +
  8 +Liste.o : ../ListeC/Liste.c ../ListeC/Liste.h
  9 + clang $(CFLAGS) -c ../ListeC/Liste.c
  10 +
  11 +Monstre.o : ../Monstre/Monstre.c ../Monstre/Monstre.h ../ListeC/Liste.h
  12 + clang $(CFLAGS) -c ../Monstre/Monstre.c
  13 +
  14 +Interactif.o : ../Interactif/Interactif.c ../Interactif/Interactif.h ../ListeC/Liste.h
  15 + clang $(CFLAGS) -c ../Interactif/Interactif.c
  16 +
  17 +init.o : init.c init.h ../ListeC/Liste.h
  18 + clang $(CFLAGS) -c init.c
  19 +
  20 +main.o : main.c ../ListeC/Liste.h
  21 + clang $(CFLAGS) -c main.c
  22 +
  23 +
  24 +$(TARGET): Liste.o main.o Monstre.o Interactif.o init.o
  25 + clang main.o Liste.o Monstre.o Interactif.o init.o -o $(TARGET) $(LDFLAGS)
  26 +
  27 +.PHONY: clean
  28 +clean:
  29 + rm -f *.o
  30 + rm -f $(TARGET)
  31 +
  32 +tidy : main.c ../ListeC/Liste.c ../Monstre/Monstre.c ../Interactif/Interactif.c init.c
  33 + $(CC)-tidy ../Interactif/Interactif.c --checks="readability-*" -header-filter=.*
  34 +
Space Invader/Envahisseurs/Graphique/src/Main/init.c 0 → 100644
@@ -0,0 +1,234 @@ @@ -0,0 +1,234 @@
  1 +#include <stdio.h>
  2 +#include <stdlib.h>
  3 +
  4 +#include "../Graphique/libgraph.h"
  5 +#include "../ListeC/Liste.h"
  6 +#include "../Interactif/Interactif.h"
  7 +#include "init.h"
  8 +
  9 +#define TailleX 500
  10 +#define TailleY 500
  11 +#define PositionX_1 TailleX / 2
  12 +#define PositionY_1 TailleY / 2
  13 +#define PositionY_2 TailleY / 4
  14 +
  15 +#define Sol 475
  16 +#define ErreurHitbox 2
  17 +#define TailletexteMax 30
  18 +
  19 +#define JoueurX TailleX/2
  20 +#define JoueurY 9*TailleY/10
  21 +
  22 +#define Nom "Space Invader"
  23 +#define TaillePolice1 TailleX / 10
  24 +#define TaillePolice2 TailleX / 20
  25 +
  26 +//Ces variables sont globales car utilisées dans plusieurs .c
  27 +//Toutes les hitbox sont initialisées 1 fois puis sont des constantes
  28 +struct entite joueur;
  29 +
  30 +int canon = 0;
  31 +int missile = 0;
  32 +int sbire = 0;
  33 +int bouillie = 0;
  34 +int bombe = 0;
  35 +
  36 +int hitboxcanonL = 0;
  37 +int hitboxcanonH = 0;
  38 +int hitboxmissileL = 0;
  39 +int hitboxmissileH = 0;
  40 +int hitboxsbireL = 0;
  41 +int hitboxsbireH = 0;
  42 +int hitboxbouillieL = 0;
  43 +int hitboxbouillieH = 0;
  44 +int hitboxbombeL = 0;
  45 +int hitboxbombeH = 0;
  46 +
  47 +//Initialisation des variables globales pour le main
  48 +void initialiser()
  49 +{
  50 + canon = chargerLutin ("../../Lutins/invader_canon.bmp",
  51 + COULEUR_NOIR);
  52 + missile = chargerLutin ("../../Lutins/invader_missile.bmp",
  53 + COULEUR_NOIR);
  54 + sbire = chargerLutin ("../../Lutins/invader_monstre1_1.bmp",
  55 + COULEUR_NOIR);
  56 + bouillie = chargerLutin ("../../Lutins/invader_monstre_bouillie.bmp",
  57 + COULEUR_NOIR);
  58 + bombe = chargerLutin ("../../Lutins/invader_bombe.bmp",
  59 + COULEUR_NOIR);
  60 +
  61 + tailleLutin (canon,
  62 + &hitboxcanonL,
  63 + &hitboxcanonH);
  64 +
  65 + tailleLutin (missile,
  66 + &hitboxmissileL,
  67 + &hitboxmissileH);
  68 +
  69 + tailleLutin (sbire,
  70 + &hitboxsbireL,
  71 + &hitboxsbireH);
  72 +
  73 + tailleLutin (bouillie,
  74 + &hitboxbouillieL,
  75 + &hitboxbouillieH);
  76 +
  77 + tailleLutin (bombe,
  78 + &hitboxbombeL,
  79 + &hitboxbombeH);
  80 +
  81 +}
  82 +
  83 +//Initialisation des coordonnées du joueur pour le main
  84 +void initialiserjoueur(struct entite* joueur)
  85 +{
  86 + joueur->posx = JoueurX;
  87 + joueur->posy = JoueurY;
  88 + joueur->dropbombe = -1;
  89 +}
  90 +
  91 +//Page de démarage du jeu
  92 +char pagedemarrage()
  93 +{
  94 + static const char policeDefaut[] = "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf";
  95 + char input = '\0';
  96 + int Largeur = 0;
  97 + int Hauteur = 0;
  98 + char jouer[] = "Appuyer sur j pour Jouer";
  99 + char quitter[] = "Appuyer ailleurs pour Quitter";
  100 +
  101 + choisirPolice (policeDefaut, TaillePolice2);
  102 + int LutinJouer = lutinTexte (jouer, COULEUR_BLANC);
  103 + int LutinQuitter = lutinTexte (quitter, COULEUR_BLANC);
  104 +
  105 + choisirPolice (policeDefaut, TaillePolice1);
  106 + int LutinBienvenue = lutinTexte (Nom, COULEUR_VERT);
  107 +
  108 + rectanglePlein (0,
  109 + 0,
  110 + TailleX,
  111 + TailleY,
  112 + COULEUR_NOIR);
  113 +
  114 + tailleLutin (LutinBienvenue,
  115 + &Largeur,
  116 + &Hauteur);
  117 + afficherLutin (LutinBienvenue,
  118 + PositionX_1 - Largeur / 2,
  119 + PositionY_2 + Hauteur / 2);
  120 +
  121 + tailleLutin (LutinJouer,
  122 + &Largeur,
  123 + &Hauteur);
  124 + afficherLutin (LutinJouer,
  125 + PositionX_1 - Largeur / 2,
  126 + PositionY_1 - Hauteur / 2);
  127 +
  128 + tailleLutin (LutinQuitter,
  129 + &Largeur,
  130 + &Hauteur);
  131 + afficherLutin (LutinQuitter,
  132 + PositionX_1 - Largeur / 2,
  133 + PositionY_1 + Hauteur / 2);
  134 +
  135 + majSurface();
  136 + attendreEvenement ();
  137 +
  138 + input = touche();
  139 + while (input == '\0')
  140 + {
  141 + input = touche();
  142 + }
  143 + return input;
  144 +}
  145 +
  146 +//Page en cas de mort dans le jeu
  147 +void pagemort (int nbr_vie)
  148 +{
  149 + static const char policeDefaut[] = "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf";
  150 + int Largeur = 0;
  151 + int Hauteur = 0;
  152 + char mort[] = "Vous etes mort";
  153 + char vie[TailletexteMax] = "\0";
  154 + sprintf(vie, "Nombre de vie restante : %d", nbr_vie);
  155 + //sprint_f crée un warning mais celui-ci ne peut pas crée d'erreur
  156 +
  157 + choisirPolice (policeDefaut, TaillePolice1);
  158 + int LutinMort = lutinTexte(mort, COULEUR_ROUGE);
  159 +
  160 + choisirPolice (policeDefaut, TaillePolice2);
  161 + int LutinVie = lutinTexte(vie, COULEUR_BLANC);
  162 +
  163 + rectanglePlein (0,
  164 + 0,
  165 + TailleX,
  166 + TailleY,
  167 + COULEUR_NOIR);
  168 +
  169 + tailleLutin (LutinMort,
  170 + &Largeur,
  171 + &Hauteur);
  172 + afficherLutin (LutinMort,
  173 + PositionX_1 - Largeur / 2,
  174 + PositionY_2 + Hauteur / 2);
  175 +
  176 + tailleLutin (LutinVie,
  177 + &Largeur,
  178 + &Hauteur);
  179 + afficherLutin (LutinVie,
  180 + PositionX_1 - Largeur / 2,
  181 + PositionY_1 - Hauteur / 2);
  182 +}
  183 +
  184 +//Page de GameOver du jeu
  185 +void pageGameOver()
  186 +{
  187 + static const char policeDefaut[] = "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf";
  188 + int Largeur = 0;
  189 + int Hauteur = 0;
  190 + char fin[] = "GAME OVER";
  191 +
  192 + choisirPolice(policeDefaut, TaillePolice1);
  193 + int LutinFin = lutinTexte(fin, COULEUR_ROUGE);
  194 +
  195 + rectanglePlein (0,
  196 + 0,
  197 + TailleX,
  198 + TailleY,
  199 + COULEUR_NOIR);
  200 +
  201 + tailleLutin (LutinFin,
  202 + &Largeur,
  203 + &Hauteur);
  204 + afficherLutin (LutinFin,
  205 + PositionX_1 - Largeur / 2,
  206 + PositionY_1 - Hauteur / 2);
  207 +
  208 +}
  209 +
  210 +//Page de Victoire du jeu
  211 +void pageVictoire()
  212 +{
  213 + static const char policeDefaut[] = "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf";
  214 + int Largeur = 0;
  215 + int Hauteur = 0;
  216 + char fin[] = "VICTOIRE";
  217 +
  218 + choisirPolice(policeDefaut, TaillePolice1);
  219 + int LutinFin = lutinTexte(fin, COULEUR_VERT);
  220 +
  221 + rectanglePlein (0,
  222 + 0,
  223 + TailleX,
  224 + TailleY,
  225 + COULEUR_NOIR);
  226 +
  227 + tailleLutin (LutinFin,
  228 + &Largeur,
  229 + &Hauteur);
  230 + afficherLutin (LutinFin,
  231 + PositionX_1 - Largeur / 2,
  232 + PositionY_1 - Hauteur / 2);
  233 +
  234 +}
Space Invader/Envahisseurs/Graphique/src/Main/init.h 0 → 100644
@@ -0,0 +1,30 @@ @@ -0,0 +1,30 @@
  1 +#include <stdio.h>
  2 +#include <stdlib.h>
  3 +
  4 +extern int canon;
  5 +extern int missile;
  6 +extern int sbire;
  7 +extern int bouillie;
  8 +extern int bombe;
  9 +
  10 +extern struct entite joueur;
  11 +extern char Nom[];
  12 +extern char input;
  13 +
  14 +extern int hitboxcanonL;
  15 +extern int hitboxcanonH;
  16 +extern int hitboxmissileL;
  17 +extern int hitboxmissileH;
  18 +extern int hitboxsbireL;
  19 +extern int hitboxsbireH;
  20 +extern int hitboxbouillieL;
  21 +extern int hitboxbouillieH;
  22 +extern int hitboxbombeL;
  23 +extern int hitboxbombeH;
  24 +
  25 +void initialiser();
  26 +void initialiserjoueur(struct entite* joueur);
  27 +char pagedemarrage();
  28 +void pagemort(int nbr_vie);
  29 +void pageGameOver();
  30 +void pageVictoire();
Space Invader/Envahisseurs/Graphique/src/Main/main.c 0 → 100644
@@ -0,0 +1,155 @@ @@ -0,0 +1,155 @@
  1 +#include <stdio.h>
  2 +#include <stdlib.h>
  3 +#include <unistd.h>
  4 +#include <SDL/SDL.h>
  5 +#include "../Graphique/libgraph.h"
  6 +#include "../ListeC/Liste.h"
  7 +#include "../Monstre/Monstre.h"
  8 +#include "../Interactif/Interactif.h"
  9 +#include "init.h"
  10 +
  11 +#define TailleX 500
  12 +#define TailleY 500
  13 +#define Sol 475
  14 +#define ErreurHitbox 2
  15 +#define Nom "Space Invader"
  16 +
  17 +int main()
  18 +{
  19 + creerSurface(TailleX,TailleY,Nom);
  20 +
  21 + initialiser();
  22 + initialiserjoueur(&joueur);
  23 +
  24 + struct liste_entite *enemies = NULL;
  25 + struct liste_entite *tires = NULL;
  26 + struct liste_entite *bombes = NULL;
  27 + //joueur est dans une liste pour que je puisse utiliser des fonctions deja créé
  28 + struct liste_entite* Ljoueur = NULL;
  29 + ajout_tete(&Ljoueur,joueur);
  30 +
  31 +
  32 + LigneSbire(&enemies,8,3);
  33 + int SensVague=1;
  34 +
  35 + char input = '\0';
  36 + int compteur = 0;
  37 + int DropAlea = 0;
  38 + int CheckAlea = 0;
  39 + int mort = 0;
  40 + int nbr_vie = 3;
  41 +
  42 + int coeur = chargerLutin ("../../Lutins/Coeur.bmp",
  43 + COULEUR_NOIR);
  44 + int hitboxcoeurL,hitboxcoeurH;
  45 + tailleLutin (coeur,
  46 + &hitboxcoeurL,
  47 + &hitboxcoeurH);
  48 +
  49 + if ( pagedemarrage() != 'j')
  50 + {
  51 + return 0;
  52 + }
  53 + SDL_Delay(500);
  54 +
  55 + //Bouble principale
  56 + while(input!='m')
  57 + {
  58 + if (mort == 1)
  59 + {
  60 + nbr_vie-=1;
  61 + if (nbr_vie > 0)
  62 + {
  63 + pagemort(nbr_vie);
  64 + majSurface();
  65 + SDL_Delay(2000);
  66 + mort = 0;
  67 + }
  68 + else
  69 + {
  70 + pageGameOver();
  71 + majSurface();
  72 + SDL_Delay(2000);
  73 + return 0;
  74 + }
  75 + ajout_tete(&Ljoueur,joueur);
  76 + tires = NULL;
  77 + bombes = NULL;
  78 + }
  79 +
  80 + rectanglePlein(0,0,TailleX,TailleY,COULEUR_NOIR);
  81 +
  82 + if (nbr_vie == 3)
  83 + {
  84 + afficherLutin(coeur,Sol-2*hitboxcoeurL,Sol);
  85 + }
  86 + if (nbr_vie >= 2)
  87 + {
  88 + afficherLutin(coeur,Sol-hitboxcoeurL,Sol);
  89 + }
  90 + afficherLutin(coeur,Sol,Sol);
  91 +
  92 + rectanglePlein(0,Sol,TailleX,2,COULEUR_VERT);
  93 +
  94 +
  95 + afficherLutin(canon,Ljoueur->entite.posx - hitboxcanonL/2 + ErreurHitbox,Ljoueur->entite.posy);
  96 + AfficherSbire(enemies,sbire,hitboxsbireL,hitboxsbireH);
  97 +
  98 + if (DropAlea == 0)
  99 + {
  100 + DropAlea = rand() % 31 + 100;
  101 + }
  102 + if (CheckAlea == DropAlea)
  103 + {
  104 + MakeBombeDroppable(enemies,&bombes);
  105 + DropAlea=0;
  106 + CheckAlea=0;
  107 + }
  108 +
  109 +
  110 + input = touche();
  111 + action(&Ljoueur->entite,input,&tires);
  112 +
  113 +
  114 + if (compteur==2)
  115 + {
  116 + DeplacementSbire(enemies,&SensVague,1);
  117 + compteur=0;
  118 + }
  119 +
  120 + DeplacementTire(&tires);
  121 + DeplacementBombe(&bombes);
  122 +
  123 + SupprimerEntitesEnCollision(&tires,hitboxmissileL,hitboxmissileH,&enemies,hitboxsbireL,hitboxsbireH);
  124 +
  125 + if (SupprimerEntitesEnCollision(&bombes,hitboxbombeL,hitboxbombeH,&Ljoueur,hitboxcanonL,hitboxcanonH) == 1)
  126 + {
  127 + mort = 1;
  128 + majSurface();
  129 + SDL_Delay(200);
  130 + }
  131 + if (SupprimerEntitesEnCollision(&enemies,hitboxsbireL,hitboxsbireH,&Ljoueur,hitboxcanonL,hitboxcanonH) == 1)
  132 + {
  133 + pageGameOver();
  134 + majSurface();
  135 + SDL_Delay(2000);
  136 + return 0;
  137 + }
  138 +
  139 + if (enemies == NULL)
  140 + {
  141 + pageVictoire();
  142 + majSurface();
  143 + SDL_Delay(2000);
  144 + return 0;
  145 + }
  146 +
  147 + majSurface();
  148 + SDL_Delay(20);
  149 +
  150 + compteur += 1;
  151 + CheckAlea += 1;
  152 +
  153 + }
  154 + return 0;
  155 +}
Space Invader/Envahisseurs/Graphique/src/Monstre/Monstre.c 0 → 100644
@@ -0,0 +1,105 @@ @@ -0,0 +1,105 @@
  1 +#include <stdio.h>
  2 +#include <stdlib.h>
  3 +
  4 +#include "../Graphique/libgraph.h"
  5 +#include "../ListeC/Liste.h"
  6 +#include "Monstre.h"
  7 +
  8 +#define TailleX 500
  9 +#define TailleY 500
  10 +#define ErreurHitbox 2
  11 +
  12 +#define Taille1_10 TailleX / 10
  13 +#define Taille9_10 9 * TailleX / 10
  14 +#define TailleJump 30
  15 +
  16 +//Sens = 1 -> Va vers la droite
  17 +//Sens = 0 -> Va vers la gauche
  18 +void DeplacementSbire(struct liste_entite* Liste,
  19 + int* SensDeplacement,
  20 + int Vitesse)
  21 +{
  22 +
  23 + int ind = 0;
  24 + struct liste_entite* pListe = Liste;
  25 +
  26 + while (pListe != NULL)
  27 + {
  28 + pListe->entite.posx += (*SensDeplacement == 1) ? Vitesse : -Vitesse;
  29 + if (pListe->entite.posx >= Taille9_10)
  30 + {
  31 + ind = 1;
  32 + }
  33 +
  34 + else if (pListe->entite.posx <= Taille1_10)
  35 + {
  36 + ind = 2;
  37 + }
  38 +
  39 + pListe = pListe->suivant;
  40 + }
  41 +
  42 + if (ind != 0)
  43 + {
  44 + *SensDeplacement = (ind == 1) ? 0 : 1;
  45 + struct liste_entite* p2Liste = Liste;
  46 +
  47 + while (p2Liste != NULL)
  48 + {
  49 + p2Liste->entite.posy += TailleJump;
  50 + p2Liste = p2Liste->suivant;
  51 + }
  52 + }
  53 +}
  54 +
  55 +//Création de lignes d'entités enemies dans la liste enemies
  56 +void LigneSbire (struct liste_entite** ListeSbire,
  57 + int nbr_enemies,
  58 + int nbr_rangee)
  59 +{
  60 +
  61 + for (int j = 1; j <= nbr_rangee; j++)
  62 + {
  63 + int compteurY = j * Taille1_10;
  64 + int compteurX = TailleX / (nbr_enemies+1);
  65 +
  66 + for (int i = 0; i < nbr_enemies; i++)
  67 + {
  68 + if (j == nbr_rangee)
  69 + {
  70 + ajout_tete(ListeSbire,
  71 + creer_entite(compteurX,
  72 + compteurY,
  73 + 1));
  74 + compteurX += 2 * TailleX / (3 * nbr_enemies);
  75 + }
  76 +
  77 + else
  78 + {
  79 + ajout_tete(ListeSbire,
  80 + creer_entite(compteurX,
  81 + compteurY,
  82 + 0));
  83 + compteurX += 2 * TailleX / (3 * nbr_enemies);
  84 + }
  85 + }
  86 + }
  87 +}
  88 +
  89 +//Affichage des enemies centrés dans leur hitbox
  90 +void AfficherSbire (struct liste_entite* Liste,
  91 + int lutin,
  92 + int Largeur,
  93 + int Hauteur)
  94 +{
  95 +
  96 + struct liste_entite* pListe = Liste;
  97 +
  98 + while (pListe != NULL)
  99 + {
  100 + afficherLutin(lutin,
  101 + pListe->entite.posx - Largeur / 2 + ErreurHitbox,
  102 + pListe->entite.posy - Hauteur / 2 + ErreurHitbox);
  103 + pListe=pListe->suivant;
  104 + }
  105 +}
Space Invader/Envahisseurs/Graphique/src/Monstre/Monstre.h 0 → 100644
@@ -0,0 +1,15 @@ @@ -0,0 +1,15 @@
  1 +#include <stdio.h>
  2 +#include <stdlib.h>
  3 +
  4 +void DeplacementSbire(struct liste_entite* Liste,
  5 + int* SensDeplacement,
  6 + int Vitesse);
  7 +
  8 +void LigneSbire (struct liste_entite** ListeSbire,
  9 + int nbr_enemies,
  10 + int nbr_rangee);
  11 +
  12 +void AfficherSbire (struct liste_entite* Liste,
  13 + int lutin,
  14 + int Largeur,
  15 + int Hauteur);