Commit fda0ca311def1c3dbdbe351a382b00d0086af973
1 parent
0b5eb1df
1ere Version bis
Showing
11 changed files
with
424 additions
and
238 deletions
Show diff stats
| @@ -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 |
| @@ -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 | +} |
| @@ -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); |
ListeC/Liste.c deleted
| @@ -1,41 +0,0 @@ | @@ -1,41 +0,0 @@ | ||
| 1 | -#include <stdio.h> | ||
| 2 | -#include <stdlib.h> | ||
| 3 | -#include "Liste.h" | ||
| 4 | - | ||
| 5 | -void creer_liste(struct liste_entite *l) | ||
| 6 | -{ | ||
| 7 | - l = malloc(sizeof(struct liste_entite)); | ||
| 8 | -} | ||
| 9 | - | ||
| 10 | -struct entite creer_entite(int x, int y, int idd) | ||
| 11 | -{ | ||
| 12 | - struct entite e; | ||
| 13 | - e.posx=x; | ||
| 14 | - e.posy=y; | ||
| 15 | - e.id=idd; | ||
| 16 | - return e; | ||
| 17 | -} | ||
| 18 | - | ||
| 19 | -void ajout_tete(struct liste_entite **pL, struct entite x) | ||
| 20 | -{ | ||
| 21 | - struct liste_entite *tmp; | ||
| 22 | - tmp = malloc(sizeof(struct liste_entite)); | ||
| 23 | - tmp->enti = x; | ||
| 24 | - tmp->suivant = *pL; | ||
| 25 | - *pL = tmp; | ||
| 26 | -} | ||
| 27 | - | ||
| 28 | - | ||
| 29 | -void imprimer_liste(struct liste_entite *l) | ||
| 30 | -{ | ||
| 31 | - struct liste_entite *p; | ||
| 32 | - p = l; | ||
| 33 | - while (p != NULL) | ||
| 34 | - { | ||
| 35 | - printf("%d -> ",p->enti.posx); | ||
| 36 | - p=p->suivant; | ||
| 37 | - } | ||
| 38 | - printf("\n"); | ||
| 39 | -} | ||
| 40 | - | ||
| 41 | - |
ListeC/Liste.h deleted
| @@ -1,25 +0,0 @@ | @@ -1,25 +0,0 @@ | ||
| 1 | -#include <stdio.h> | ||
| 2 | -#include <stdlib.h> | ||
| 3 | - | ||
| 4 | -struct entite | ||
| 5 | -{ | ||
| 6 | - int posx; | ||
| 7 | - int posy; | ||
| 8 | - int id; | ||
| 9 | -}; | ||
| 10 | - | ||
| 11 | - | ||
| 12 | -struct liste_entite | ||
| 13 | -{ | ||
| 14 | - struct entite enti; | ||
| 15 | - struct liste_entite *suivant; | ||
| 16 | -}; | ||
| 17 | - | ||
| 18 | - | ||
| 19 | -void ajout_tete(struct liste_entite**, struct entite); | ||
| 20 | - | ||
| 21 | -void creer_liste(struct liste_entite*); | ||
| 22 | - | ||
| 23 | -struct entite creer_entite(int,int,int); | ||
| 24 | - | ||
| 25 | -void imprimer_liste(struct liste_entite*); |
Main/Makefile deleted
| @@ -1,27 +0,0 @@ | @@ -1,27 +0,0 @@ | ||
| 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 | -Missile.o : ../Missile/Missile.c ../Missile/Missile.h ../ListeC/Liste.h | ||
| 15 | - clang $(CFLAGS) -c ../Missile/Missile.c | ||
| 16 | - | ||
| 17 | -main.o : main.c ../ListeC/Liste.h | ||
| 18 | - clang $(CFLAGS) -c main.c | ||
| 19 | - | ||
| 20 | - | ||
| 21 | -$(TARGET): Liste.o main.o Monstre.o Missile.o | ||
| 22 | - clang main.o Liste.o Monstre.o Missile.o -o $(TARGET) $(LDFLAGS) | ||
| 23 | - | ||
| 24 | -.PHONY: clean | ||
| 25 | -clean: | ||
| 26 | - rm -f *.o | ||
| 27 | - rm -f $(TARGET) |
Main/main.c deleted
| @@ -1,63 +0,0 @@ | @@ -1,63 +0,0 @@ | ||
| 1 | -#include <stdio.h> | ||
| 2 | -#include <unistd.h> | ||
| 3 | -#include <SDL/SDL.h> | ||
| 4 | -#include "../Graphique/libgraph.h" | ||
| 5 | -#include "../ListeC/Liste.h" | ||
| 6 | -#include "../Monstre/Monstre.h" | ||
| 7 | -#include "../Missile/Missile.h" | ||
| 8 | - | ||
| 9 | -#define TailleX 500 | ||
| 10 | -#define TailleY 500 | ||
| 11 | -//clang Try.c -I Graphique -l graph -L Graphique -l SDL -l SDL_ttf | ||
| 12 | - | ||
| 13 | - | ||
| 14 | -char touche() | ||
| 15 | -{ | ||
| 16 | - char touche; | ||
| 17 | - evenement even; | ||
| 18 | - lireEvenement (&even,&touche,NULL); | ||
| 19 | - return touche; | ||
| 20 | -} | ||
| 21 | - | ||
| 22 | -int main() | ||
| 23 | -{ | ||
| 24 | - struct liste_entite *enemies = NULL; | ||
| 25 | - creer_liste(enemies); | ||
| 26 | - ajout_tete(&enemies,creer_entite(50,50,0)); | ||
| 27 | - ajout_tete(&enemies,creer_entite(150,50,0)); | ||
| 28 | - ajout_tete(&enemies,creer_entite(250,50,0)); | ||
| 29 | - imprimer_liste(enemies); | ||
| 30 | - int sens=1; | ||
| 31 | - int *psens=&sens; | ||
| 32 | - | ||
| 33 | - struct entite joueur; | ||
| 34 | - joueur.posx=225; | ||
| 35 | - joueur.posy=470; | ||
| 36 | - int canon = chargerLutin("../../Lutins/invader_canon.bmp",COULEUR_NOIR); | ||
| 37 | - | ||
| 38 | - struct liste_entite *tires = NULL; | ||
| 39 | - creer_liste(tires); | ||
| 40 | - //ajout_tete(&tires,creer_entite(225,470,0)); | ||
| 41 | - Tirer(joueur,&tires); | ||
| 42 | - imprimer_liste(tires); | ||
| 43 | - int missile = chargerLutin("../../Lutins/invader_missile.bmp",COULEUR_NOIR); | ||
| 44 | - | ||
| 45 | - char Nom[20]="PremiereFenetre"; | ||
| 46 | - creerSurface(TailleX,TailleY,Nom); | ||
| 47 | - int lulu = chargerLutin("../../Lutins/invader_monstre1_1.bmp",COULEUR_NOIR); | ||
| 48 | - | ||
| 49 | - while(1) | ||
| 50 | - { | ||
| 51 | - afficherLutin(canon,joueur.posx,joueur.posy); | ||
| 52 | - DeplacementLutin(lulu,enemies,psens,1); | ||
| 53 | - | ||
| 54 | - char c = touche(); | ||
| 55 | - printf("%c",c); | ||
| 56 | - DeplacementTire(missile,tires); | ||
| 57 | - | ||
| 58 | - majSurface(); | ||
| 59 | - rectanglePlein(0,0,TailleX,TailleY,COULEUR_NOIR); | ||
| 60 | - SDL_Delay(20); | ||
| 61 | - } | ||
| 62 | - return 0; | ||
| 63 | -} |
Missile/Missile.c deleted
| @@ -1,23 +0,0 @@ | @@ -1,23 +0,0 @@ | ||
| 1 | -#include <stdio.h> | ||
| 2 | -#include <stdlib.h> | ||
| 3 | -#include "../Graphique/libgraph.h" | ||
| 4 | -#include "../ListeC/Liste.h" | ||
| 5 | -#include "Missile.h" | ||
| 6 | - | ||
| 7 | - | ||
| 8 | -void Tirer(struct entite joueur, struct liste_entite **pl) | ||
| 9 | -{ | ||
| 10 | - ajout_tete(pl,creer_entite(joueur.posx+18,joueur.posy-5,0)); | ||
| 11 | -} | ||
| 12 | - | ||
| 13 | - | ||
| 14 | -void DeplacementTire(int tire,struct liste_entite *l) | ||
| 15 | -{ | ||
| 16 | - struct liste_entite *ml=l; | ||
| 17 | - while(ml != NULL) | ||
| 18 | - { | ||
| 19 | - ml->enti.posy-=5; | ||
| 20 | - afficherLutin(tire,ml->enti.posx,ml->enti.posy); | ||
| 21 | - ml=ml->suivant; | ||
| 22 | - } | ||
| 23 | -} |
Missile/Missile.h deleted
Monstre/Monstre.c deleted
| @@ -1,49 +0,0 @@ | @@ -1,49 +0,0 @@ | ||
| 1 | -#include <stdio.h> | ||
| 2 | -#include <stdlib.h> | ||
| 3 | -#include "../Graphique/libgraph.h" | ||
| 4 | -#include "../ListeC/Liste.h" | ||
| 5 | -#include "Monstre.h" | ||
| 6 | - | ||
| 7 | -//sens 1 = Va vers la droite | ||
| 8 | -void DeplacementLutin(int lutin,struct liste_entite *l, int *psens, int speed) | ||
| 9 | -{ | ||
| 10 | - int ind=0; | ||
| 11 | - struct liste_entite *ml=l; | ||
| 12 | - while(ml != NULL) | ||
| 13 | - { | ||
| 14 | - if (*psens==1) | ||
| 15 | - { | ||
| 16 | - ml->enti.posx+=speed; | ||
| 17 | - if(ml->enti.posx>=450)ind=1; | ||
| 18 | - afficherLutin(lutin,ml->enti.posx,ml->enti.posy); | ||
| 19 | - } | ||
| 20 | - else | ||
| 21 | - { | ||
| 22 | - ml->enti.posx-=speed; | ||
| 23 | - if(ml->enti.posx<=50)ind=2; | ||
| 24 | - afficherLutin(lutin,ml->enti.posx,ml->enti.posy); | ||
| 25 | - } | ||
| 26 | - ml=ml->suivant; | ||
| 27 | - } | ||
| 28 | - if (ind==1) | ||
| 29 | - { | ||
| 30 | - *psens=0; | ||
| 31 | - struct liste_entite *ml2=l; | ||
| 32 | - while(ml2 != NULL) | ||
| 33 | - { | ||
| 34 | - ml2->enti.posy+=30; | ||
| 35 | - ml2=ml2->suivant; | ||
| 36 | - } | ||
| 37 | - } | ||
| 38 | - else if (ind==2) | ||
| 39 | - { | ||
| 40 | - *psens=1; | ||
| 41 | - struct liste_entite *ml2=l; | ||
| 42 | - while(ml2 != NULL) | ||
| 43 | - { | ||
| 44 | - ml2->enti.posy+=30; | ||
| 45 | - ml2=ml2->suivant; | ||
| 46 | - } | ||
| 47 | - } | ||
| 48 | -} | ||
| 49 | - |
Monstre/Monstre.h deleted