"premiere livraison"

RABIA
Showing 8 changed files with 560 additions and 0 deletions Show diff stats
invader_bouclier.bmp
invader_canon.bmp
invader_monstre1_1.bmp
libgraph.c
libgraph.h
makefile
test.c
test.h
+++ a/libgraph.c
@@ -0,0 +1,239 @@
+/**** Bibliotheque graphique ****/
+
+/** Fichiers d'inclusion **/
+
+#include <SDL/SDL.h>
+#include <SDL/SDL_ttf.h>
+#include "libgraph.h"
+
+/** Types **/
+
+typedef struct
+{
+    int r, v, b;
+} couleur;
+
+/** Constantes **/
+
+#define BITS_PAR_PIXEL 32
+#define TAILLE_POLICE 20
+
+static const couleur couleurs[] = { { 255, 255, 255 }, { 0, 0, 0 },   { 255, 0, 0 },
+                                    { 0, 255, 0 },     { 0, 0, 255 }, { 255, 105, 180 },
+                                    { 150, 150, 150 }, { -1, -1, -1 } };
+
+static const char policeDefaut[]="/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf";
+
+/** Variables globales **/
+
+static SDL_Surface *surface;
+TTF_Font* police;
+
+/** Fonctions **/
+
+void choisirPolice(const char *chemin, int taille){
+  police=TTF_OpenFont(chemin, taille);
+}
+
+void initialiserTexte() {
+  TTF_Init();
+  choisirPolice(policeDefaut, TAILLE_POLICE);
+}
+
+/* Initialisation de la surface dessinable */
+unsigned char creerSurface (int largeur, int hauteur, char *titre)
+{
+    SDL_Init (SDL_INIT_VIDEO);
+    SDL_WM_SetCaption (titre, titre);
+    surface = SDL_SetVideoMode (largeur, hauteur, BITS_PAR_PIXEL, SDL_DOUBLEBUF);
+    initialiserTexte();
+    
+    return (surface != NULL && police != NULL);
+}
+
+/* Fermeture de la surface dessinable */
+
+void fermerSurface (void)
+{
+    if (surface != NULL) SDL_FreeSurface (surface);
+    if (police != NULL) TTF_CloseFont(police);
+    TTF_Quit();
+    SDL_Quit ();
+}
+
+/* Creation d'une couleur */
+
+static int creerCouleur (int ncouleur)
+{
+    couleur c = couleurs[ncouleur];
+    return SDL_MapRGB (surface->format, c.r, c.v, c.b);
+}
+
+/* Dessin d'un rectangle plein */
+
+void rectanglePlein (int x, int y, int l, int h, int c)
+{
+    SDL_Rect rectangle = { x, y, l, h };
+    SDL_FillRect (surface, &rectangle, creerCouleur (c));
+    // SDL_Flip(surface);
+}
+
+/* Manipulation de lutins */
+
+static SDL_Surface *lutins[MAX_LUTINS];
+static int          lutins_nb = 0;
+
+int lutinTexte(char* texte, int couleurTexte) {
+  couleur c=couleurs[couleurTexte];
+  SDL_Color couleur={c.r, c.v, c.b};
+  SDL_Surface* lutin=TTF_RenderText_Solid(police, texte, couleur);
+  if (lutin != NULL)
+    {
+      lutins[lutins_nb++] = lutin;
+      return lutins_nb - 1;
+    }
+  return -1;
+}
+
+static void configurerLutin (SDL_Surface *lutin, int ncouleur)
+{
+    couleur c    = couleurs[ncouleur];
+    int     fond = SDL_MapRGB (lutin->format, c.r, c.v, c.b);
+    SDL_SetColorKey (lutin, SDL_SRCCOLORKEY | SDL_RLEACCEL, fond);
+}
+
+int chargerLutin (char *fichier, int couleur)
+{
+    if (lutins_nb >= MAX_LUTINS) return -2;
+    SDL_Surface *lutin = SDL_LoadBMP (fichier);
+    if (lutin != NULL)
+    {
+        lutins[lutins_nb++] = lutin;
+        if (couleur >= 0) configurerLutin (lutin, couleur);
+        return lutins_nb - 1;
+    }
+    return -1;
+}
+
+void afficherLutin (int lutin, int x, int y)
+{
+    SDL_Rect position;
+    position.x = x;
+    position.y = y;
+    SDL_BlitSurface (lutins[lutin], NULL, surface, &position);
+}
+
+int creerLutin (int x, int y, int largeur, int hauteur, int couleur)
+{
+    if (lutins_nb >= MAX_LUTINS) return -2;
+    int rmask, gmask, bmask, amask;
+#if SDL_BYTEORDER == SDL_BIG_ENDIAN
+    rmask = 0xff000000;
+    gmask = 0x00ff0000;
+    bmask = 0x0000ff00;
+    amask = 0x000000ff;
+#else
+    rmask = 0x000000ff;
+    gmask = 0x0000ff00;
+    bmask = 0x00ff0000;
+    amask = 0xff000000;
+#endif
+    if (couleur < 0) amask = 0x00000000;
+    SDL_Surface *lutin =
+    SDL_CreateRGBSurface (0, largeur, hauteur, BITS_PAR_PIXEL, rmask, gmask, bmask, amask);
+    SDL_Rect fenetre;
+    fenetre.x = x;
+    fenetre.y = y;
+    fenetre.h = hauteur;
+    fenetre.w = largeur;
+    SDL_BlitSurface (surface, &fenetre, lutin, NULL);
+    lutins[lutins_nb++] = lutin;
+    if (couleur >= 0) configurerLutin (lutin, couleur);
+    return lutins_nb - 1;
+}
+
+void tailleLutin (int lutin, int *largeur, int *hauteur)
+{
+    *largeur = lutins[lutin]->w;
+    *hauteur = lutins[lutin]->h;
+}
+
+int sauverLutin (int lutin, char *nom) { return SDL_SaveBMP (lutins[lutin], nom); }
+
+/* Manipulation de copie de surface en BMP */
+
+int sauverSurface (char *fichier) { return SDL_SaveBMP (surface, fichier); }
+
+unsigned char chargerSurface (char *fichier)
+{
+    SDL_Surface *image = SDL_LoadBMP (fichier);
+    if (image != NULL)
+    {
+        SDL_BlitSurface (image, NULL, surface, NULL);
+        SDL_Flip (surface);
+    }
+    return (image != NULL);
+}
+
+void majSurface (void) { SDL_Flip (surface); }
+
+/* Trouver la couleur d'un pixel */
+
+int couleurPixel (int x, int y)
+{
+    int     bpp = surface->format->BytesPerPixel;
+    Uint32 *p   = (Uint32 *)(surface->pixels + y * surface->pitch + x * bpp);
+    Uint8   r, v, b;
+    SDL_GetRGB (*p, surface->format, &r, &v, &b);
+    int i = 0;
+    while (1)
+    {
+        if (couleurs[i].r < 0) break;
+        if (r == couleurs[i].r && v == couleurs[i].v && b == couleurs[i].b) break;
+        i++;
+    }
+    if (couleurs[i].r < 0)
+        return -1;
+    else
+        return i;
+}
+
+/* Fonction de traitement des événements */
+
+void lireEvenement (evenement *evt, char *touche, void **detail)
+{
+    static SDL_keysym _detail;
+    SDL_Event         event;
+    while (SDL_PollEvent (&event))
+    {
+        if (event.type == SDL_QUIT) *evt = quitter;
+        if (event.type == SDL_KEYDOWN || event.type == SDL_KEYUP)
+        {
+            *evt      = (event.type == SDL_KEYDOWN) ? toucheBas : toucheHaut;
+            char *nom = SDL_GetKeyName (event.key.keysym.sym);
+            if (strlen (nom) == 1 && nom[0] >= 32 && nom[0] < 128)
+                *touche = nom[0];
+            else
+                *touche = 0;
+            if (detail != NULL)
+            {
+                _detail = event.key.keysym;
+                *detail = &_detail;
+            }
+	    break;
+        }
+    }
+}
+
+void attendreEvenement (void)
+{
+    SDL_Event event;
+    while (SDL_WaitEvent (&event)) switch (event.type)
+        {
+        case SDL_QUIT:
+            exit (0);
+        case SDL_KEYDOWN:
+        case SDL_MOUSEBUTTONDOWN:
+            return;
+        }
+}
+++ a/libgraph.h
@@ -0,0 +1,156 @@
+/**** Bibliotheque graphique (definitions) ****/
+
+/** Constantes **/
+
+#define COULEUR_BLANC 0
+#define COULEUR_NOIR 1
+#define COULEUR_ROUGE 2
+#define COULEUR_VERT 3
+#define COULEUR_BLEU 4
+#define COULEUR_ROSE 5
+#define COULEUR_GRIS 6
+
+#define MAX_LUTINS 16
+
+typedef enum {toucheBas, toucheHaut, quitter} evenement;
+
+/** Prototypes **/
+
+/**
+ * @brief cree une fenetre 2D
+ *
+ * @param largeur en pixels de la fenetre
+ * @param hauteur en pixels de la fenetre
+ * @param titre   de la fenetre (chaine de caractere)
+ */
+unsigned char creerSurface (int largeur, int hauteur, char *titre);
+
+/**
+ * @brief permet de charger un fichier image au format bmp (bitmap)
+ *
+ * @param fichier nom du fichier
+ */
+unsigned char chargerSurface (char *fichier);
+
+
+/**
+ * @brief permet de sauvegarder une surface en image (format bmp)
+ *
+ * @param fichier   nom du fichier
+ * @return          0 si OK, valeur negative sinon
+ */
+int sauverSurface (char *fichier);
+
+/**
+ * @brief met a jour la surface d'affichage
+ */
+void majSurface (void);
+
+
+/**
+ * @brief libere la surface d'affichage
+ *        a faire lors de la fermeture
+ *        du programme
+ */
+void fermerSurface (void);
+
+/**
+ * @brief choisit la police de caractères à utiliser pour afficher du texte
+ * @param chemin nom du fichier de police (format .ttf, voir /usr/share/fonts/truetype)
+ * @param taille taille de la police
+ */
+void choisirPolice(const char *chemin, int taille);
+
+/**
+ * @brief   dessine un rectange de taille (l,h) aux coordonnêes
+ *          (x,y) et de couleur c
+ *
+ * @param x 0 <= x <= l_surface
+ * @param y 0 <= y <= h_surface
+ * @param l largeur en pixels
+ * @param h longueur en pixels
+ * @param c indice de couleur voir variable couleurs dans le fichier .c
+ */
+void rectanglePlein (int x, int y, int l, int h, int c);
+
+
+/**
+ * @brief permet de determiner l'indice du tableau de couleur du
+ *        pixel aux coordonnees (x,y)
+ *
+ * @param x 0 <= x <= l_surface
+ * @param y 0 <= y <= h_surface
+ * @return indice de couleur voire variable couleurs dans le fichier .c
+ */
+int couleurPixel (int x, int y);
+
+/**
+ * @brief crée un lutin à partir d'un texte
+ *
+ * @param texte le texte
+ * @param couleur indice de couleur du texte
+ * @return numero de lutin dans le tableau dynamique de lutin (< MAX_LUTINS)
+ */
+int lutinTexte(char *texte, int couleur);
+
+/**
+ * @brief charge un lutin à partir du fichier
+ *
+ * @param fichier image bitmap du lutin à charger
+ * @param couleur indice de couleurs à charger
+ * @return numero de lutin dans le tableau dynamique de lutin (< MAX_LUTINS)
+ */
+int chargerLutin (char *fichier, int couleur);
+
+/**
+ * @brief afficher un lutin aux coordonnées (x,y)
+ *
+ * @param lutin numero du lutin à afficher (< MAX_LUTINS)
+ * @param x     abscisse de départ
+ * @param y     ordonnée de départ
+ */
+void afficherLutin (int lutin, int x, int y);
+
+/**
+ * @brief creer un lutin de taille (l,h) aux coordonnées (x,y)
+ *
+ * @param x         abscisse de départ
+ * @param y         ordonnée de départ
+ * @param largeur   largeur du lutin
+ * @param hauteur   hauteur du lutin
+ * @param couleur   indice de couleur à partir du tableau _couleurs_
+ * @return          indice du lutin dans le tableau global (< MAX_LUTINS)
+ */
+int creerLutin (int x, int y, int largeur, int hauteur, int couleur);
+
+/**
+ * @brief       sauvegarde un lutin dans un fichier
+ *
+ * @param lutin numero de lutin à sauvegarder (< MAX_LUTINS)
+ * @param nom   fichier pour la sauvegarde
+ * @return      0 si OK valeur négative sinon
+ */
+int sauverLutin (int lutin, char *nom);
+
+/**
+ * @brief calcule la taille (largeur,hauteur) d'un lutin
+ *
+ * @param lutin     index du lutin (< MAX_LUTINS)
+ * @param largeur   pointeur sur la largeur
+ * @param hauteur   pointeur sur la hauteur
+ */
+void tailleLutin (int lutin, int *largeur, int *hauteur);
+
+/**
+ * @brief lire une touche au clavier
+ *
+ * @param evt    pointeur sur evenement
+ * @param touche pointeur sur la touche pressée
+ * @param detail NULL ou keysim
+ */
+void lireEvenement (evenement *evt, char *touche, void **detail);
+
+/**
+ * @brief attente d'un evenement bouton, souris, fin de programme
+ */
+void attendreEvenement (void);
+++ a/makefile
@@ -0,0 +1,28 @@
+# Makefile for the graphical library (libgraph.a)
+
+# Compiler and archiver
+CC = gcc
+AR = ar
+CFLAGS = -Wall -g
+ARFLAGS = rs
+
+# Source files and objects
+SOURCES = $(wildcard *.c)
+OBJETS = $(SOURCES:.c=.o)
+CIBLE = libgraph.a
+
+# Main target
+.PHONY: all
+all: $(CIBLE)
+
+# Clean rule
+.PHONY: clean
+clean:
+	rm -f core *.o $(CIBLE)
+
+# Dependencies for the library
+$(CIBLE): $(OBJETS)
+	$(AR) $(ARFLAGS) $@ $^
+
+
+
+++ a/test.c
@@ -0,0 +1,96 @@
+#include <stdio.h>
+#include <SDL/SDL.h>
+#include <SDL/SDL_ttf.h>
+#include "libgraph.h"
+#include "test.h"
+#include <stdbool.h>
+#include <stdlib.h>
+
+#define MAX_LUTINS 16
+#define BITS_PAR_PIXEL 32
+#define TAILLE_POLICE 20
+
+
+
+liste_entite * ajout_en_tete(liste_entite  premiere_entite,struct entite  * une_entite )
+{
+    liste_entite * nouvelleentite = (liste_entite * )malloc(sizeof(liste_entite));
+
+    if(nouvelleentite == NULL)
+    {
+        return NULL;
+    }
+
+    nouvelleentite->premiere_entite = une_entite;
+    return nouvelleentite;
+}
+
+
+liste_entite * ajout_apres(liste_entite * entite, struct entite une_entite)
+{
+//  a terminer
+
+
+
+
+    return NULL;
+}
+
+
+
+/*liste_entite * supression_entete(liste_entite * une_entite)
+
+{  if(une_entite == NULL) return NULL;
+    liste_entite * current_entite = une_entite->premiere_entite;
+    free(une_entite);
+    return current_entite;
+}*/
+
+
+
+
+
+
+
+
+/*void initiliserlejeu(void)
+{    creerSurface(800,600,"space invaders");
+
+
+
+
+
+}*/
+
+int main()
+
+{
+
+       if (creerSurface(800, 600, "Space Invaders")) {
+        int monsterSprite = chargerLutin("invader_monstre1_1.bmp", COULEUR_ROUGE);
+        if (monsterSprite != -1) {
+            afficherLutin(monsterSprite, 100, 100);
+            majSurface();
+        }
+
+        attendreEvenement();
+
+
+        rectanglePlein(0, 0, 800, 600, COULEUR_NOIR);
+        majSurface();
+
+
+        int anotherSprite = chargerLutin("invader_monstre1_1.bmp", COULEUR_BLEU);
+        if (anotherSprite != -1) {
+            afficherLutin(anotherSprite, 200, 100);
+            majSurface();
+        }
+
+        attendreEvenement();
+
+
+}
+fermerSurface();
+}
+
+
+++ a/test.h
@@ -0,0 +1,41 @@
+#ifndef test_h
+#define test_h
+
+#define type_monstre 0
+#define type_vaisseau 1
+#define type_bouclier 2
+
+typedef struct entite
+{   int x,y;
+    int etat ;
+    int identifiant_entite;
+    int type ;
+
+}entite;
+
+
+
+
+typedef struct liste_entite
+{
+    entite * premiere_entite;
+    int capacite;
+}liste_entite;
+
+
+
+liste_entite * initiliserentite(liste_entite * entite );
+liste_entite * suppression_entite(liste_entite * entite);
+
+
+
+
+
+
+
+
+
+
+
+
+#endif