Gestion des murs, génération de la map MaJ, sprite du joueur apparait,...

Gestion des murs, génération de la map MaJ, sprite du joueur apparait, plusieurs fonctions gérant SDL_Rect et l'affichage des sprite mis en place

Makefile

 CC = gcc
-CFLAGS = -W -Wall -ansi -std=c99 -g
+CFLAGS = -W -Wall -ansi -std=c99 -g 
 LIBS = -L./SDL2_ttf/.libs
 LDFLAGS = `sdl2-config --cflags --libs` -lSDL2_ttf
 INCLUDES =  -I./SDL2_ttf

constantes.h

 /**
- * \file constante.
+ * \file constantes.h
  * \brief header - constantes
  * \author Guillaume Vautrin
  * \version 1.0
@@ -87,6 +87,12 @@
  * */
 #define BLOC_COMPT_SIZE 100
 
+/**
+ * @brief Nombre de comptoire dans le niveau 1
+ * 
+ */
+#define NB_COMPT_1 10
+
 /**
  * \brief Largeur de la zone d'envoi
  * */

gestion_fichiers.c

@@ -59,7 +59,7 @@ void taille_fichier (const char* nomFichier, int* nbLig, int* nbCol){
     fclose(fichier);
 }
 
-char** lire_fichier (const char* nomFichier){ //malfonctionne
+char** lire_fichier (const char* nomFichier){
     FILE* fichier = fopen(nomFichier, "r");
     if (fichier == NULL){
         printf("Erreur: fichier inaccessible \n");

graphisme.c

@@ -9,8 +9,20 @@
 #include "graphisme.h"
 
 void clean_textures(textures_t *textures){
+  if (textures->joueur != NULL){
+    SDL_DestroyTexture(textures->joueur);
+  }
+  if (textures->fond != NULL){
+    SDL_DestroyTexture(textures->fond);
+  }
+
 }
 
+void nettoyage_graphisme (SDL_Renderer *renderer, textures_t *textures, SDL_Window *fenetre){
+  clean_textures(textures);
+  SDL_RenderClear(renderer);
+  SDL_DestroyWindow(fenetre);
+}
 
 void init_textures (SDL_Renderer *renderer, textures_t *textures, TTF_Font *font){
   textures->fond = charger_image("Ressources/fond1.bmp", renderer);
@@ -25,13 +37,23 @@ void apply_background (SDL_Renderer *renderer, textures_t *textures){
   }
 }
 
-void apply_player (SDL_Renderer *renderer, textures_t *textures){
-  // applique la texture du joueur
+void apply_sprite (SDL_Renderer *renderer, SDL_Texture *image, sprite_t *sprite){
+  // applique la texture d'un sprite
+  
+    SDL_Rect SrC = create_SDL_rect_from_texture(image);
+    SDL_Rect Des = create_SDL_rect_from_sprite(sprite);
+    SDL_RenderCopy(renderer, image, &SrC , &Des);
+}
+
+void apply_graphics (SDL_Renderer *renderer, textures_t *textures, world_t *world){
+  //maj les texture selon la position des éléments différents
   if (textures->joueur !=NULL){
-    SDL_RenderCopy(renderer, textures->fond, create_SDL_rect_from_texture(textures->joueur), NULL); // faux
+    apply_sprite (renderer, textures->joueur, &world->joueur);
   }
+
 }
 
+
 void colorier_rect (SDL_Renderer *renderer, SDL_Rect rectangle, SDL_Color couleur){
   SDL_SetRenderDrawColor(renderer, couleur.r, couleur.g, couleur.b, couleur.a);
   for (int i=0; i<rectangle.y; i++){
@@ -41,33 +63,34 @@ void colorier_rect (SDL_Renderer *renderer, SDL_Rect rectangle, SDL_Color couleu
   }
 }
 
-const SDL_Rect * create_SDL_rect_from_texture (SDL_Texture * texture){
+SDL_Rect create_SDL_rect_from_texture (SDL_Texture * texture){
   //Permet de créer un SDL_rect retournant la texture de la taille de la texture (SOURCE)
-  SDL_Rect* rectangle;
   int w;
   int h;
   SDL_QueryTexture(texture, NULL, NULL, &w, &h);
   return create_SDL_rect (0, 0, w, h);
 }
 
-const SDL_Rect* create_SDL_rect (int x, int y, int w, int h){
+SDL_Rect create_SDL_rect (int x, int y, int w, int h){
     //permet de créer un SDL_rect en connaissant déjà les coordonnées
-    SDL_Rect* rectangle;
-    rectangle->x = x;
-    rectangle->y = y;
-    rectangle->w = w;
-    rectangle->h = h;
+    SDL_Rect rectangle;
+    rectangle.x = x;
+    rectangle.y = y;
+    rectangle.w = w;
+    rectangle.h = h;
     return rectangle;
+}
 
+SDL_Rect create_SDL_rect_from_sprite (sprite_t* sprite){
+  //Permet de créer un SDL_rect basé sur les données d'un sprite
+  return create_SDL_rect (sprite->x, sprite->y, sprite->w, sprite->h);
 }
 
 void update_graphics (SDL_Renderer *renderer, world_t *world, textures_t *textures){
 
-
-
   SDL_RenderClear(renderer); // permet de vider le Renderer (ecran) de toutes les textures
   apply_background (renderer, textures);
-
+  apply_graphics(renderer, textures, world);
   SDL_RenderPresent(renderer); // Récupère les infos actualisés de render et les affiches
 
 }
\ No newline at end of file

graphisme.h

@@ -31,6 +31,15 @@ typedef struct textures_s textures_t;
  */
 void clean_textures(textures_t *textures);
 
+/**
+ * @brief Nettoyage des éléments graphiques en fin de jeu
+ * 
+ * @param renderer 
+ * @param textures 
+ * @param fenetre
+ */
+void nettoyage_graphisme (SDL_Renderer *renderer, textures_t *textures, SDL_Window *fenetre);
+
 /**
  * \brief La fonction initialise les texures
  * \param renderer la surface correspondant à l'écran de jeu
@@ -46,6 +55,24 @@ void init_textures (SDL_Renderer *renderer, textures_t *textures, TTF_Font *font
  */
 void apply_background (SDL_Renderer *renderer, textures_t *textures);
 
+/**
+ * @brief Applique une texture sur un sprite
+ * 
+ * @param renderer surface écran de jeu
+ * @param image SDL_Texture du sprite
+ * @param sprite données du sprite
+ */
+void apply_sprite (SDL_Renderer *renderer, SDL_Texture * image, sprite_t *sprite);
+
+/**
+ * @brief Applique tous les éléments graphiques sur le renderer
+ * 
+ * @param renderer surface de l'écran de jeu
+ * @param textures textures des sprites
+ * @param world données du monde dont les sprites
+ */
+void apply_graphics (SDL_Renderer *renderer, textures_t *textures, world_t *world);
+
 /**
  * @brief Créer un objet SDL_rect
  * 
@@ -53,18 +80,25 @@ void apply_background (SDL_Renderer *renderer, textures_t *textures);
  * @param y ordonnée
  * @param w largeur
  * @param h hauteur
- * @return SDL_Rect 
+ * @return const SDL_Rect* 
  */
-const SDL_Rect * create_SDL_rect (int x, int y, int w, int h);
+SDL_Rect create_SDL_rect (int x, int y, int w, int h);
 
 /**
  * @brief Créer un SDL_rect retournant la texture de la taille de la texture (SOURCE)
  * 
  * @param texture 
- * @return SDL_Rect représentant l'image source tel quel
+ * @return const SDL_Rect* représentant l'image source tel quel
  */
-const SDL_Rect * create_SDL_rect_from_texture (SDL_Texture * texture);
+SDL_Rect create_SDL_rect_from_texture (SDL_Texture * texture);
 
+/**
+ * @brief Créer un SDL_rect selon les données d'un sprite (DEST)
+ * 
+ * @param sprite 
+ * @return const SDL_Rect* 
+ */
+SDL_Rect create_SDL_rect_from_sprite (sprite_t * sprite);
 /**
  * @brief Colorie un rectangle d'une couleur donnée
  * 

logique.c

@@ -21,6 +21,13 @@ void init_data(world_t * world){ //faux
 
     //Charge la carte
     world->map = init_map();
+    //Complète automatiquement les positions d'un meuble unique sur la map
+    build_sprite_unique(&world->frigo, 'F', FRIGO_LARGEUR, FRIGO_HAUTEUR, world->map);
+    build_sprite_unique(&world->four, 'f', FOUR_LARGEUR, FOUR_HAUTEUR, world->map);
+    build_sprite_unique(&world->lavabo, 'L', LAVABO_LARGEUR, LAVABO_HAUTEUR, world->map);
+    build_sprite_unique(&world->poubelle, 't', POUBELLE_LARGEUR, POUBELLE_HAUTEUR, world->map);
+    build_sprite_unique(&world->envoi, 'e', ZONE_ENVOI_LARGEUR, ZONE_ENVOI_HAUTEUR, world->map);
+    build_sprites_tab(&world, 'X', BLOC_COMPT_SIZE, BLOC_COMPT_SIZE);
     
     
     /*
@@ -33,6 +40,54 @@ void init_data(world_t * world){ //faux
     
 }
 
+void build_sprite_unique (sprite_t *sprite, char nom, int largeur, int hauteur, char** map){
+    //Ne gère la présence que d'un sprite du même type sur la map
+    int x = 0;
+    int y = 0;
+    int comptX = 0;
+    int comptY = 0;
+
+    for (int i=0; i<SCREEN_HEIGHT; i++){
+        for (int j=0; j<SCREEN_WIDTH; j++){
+            if (map[i][j] == nom){
+                //On compte le nombre de char correspondant à une ligne dans le tableau
+                y = i;
+                x = j;
+                break;
+            }
+        }
+    }
+    while (map[y][x]== nom){ // On regarde jusqu'où s'étend la taille du sprite (width)
+        comptX++;
+        //printf("\n %d", comptX);
+        x++;
+    }
+    x -= comptX; //retour au point de départ
+
+    while (map[y][x] == nom){ // On regarde jusqu'où s'étend la taille du sprite (height)
+        comptY++;
+        y--;
+    }
+    y += comptY; // retour au point de départ
+
+    //Gestion des positions possibles.
+    if (comptX == largeur && comptY == hauteur){
+        init_sprite(sprite, nom, x, y, largeur, hauteur, 0, 0);
+    }
+    if (comptX == hauteur && comptY == largeur){
+        init_sprite(sprite, nom, x, y, hauteur, largeur, 0, 0);
+    }
+}
+
+void build_sprites_tab (world_t* world, char nomSprite, int largeur, int hauteur){
+
+    for (int i=0; i<SCREEN_HEIGHT; i++){
+        for (int j=0; j<SCREEN_WIDTH; j++){
+            //Parcours du tableau pour repérer le premier caractère d'un
+        }
+    }
+}
+
 void init_sprite(sprite_t *sprite, char nom, int x, int y, int w, int h, int v, int state){ //faux 
     //La fonction initialise tous les composants d'un sprite
     sprite->x = x;
@@ -92,24 +147,24 @@ int estFini(world_t *world){
 
 void limites_externes (sprite_t *sprite, world_t *world){
     //Défini les limites selon les murs
-    if (sprite->x > (SCREEN_WIDTH*0.9)){
+    if (sprite->x + sprite->w > SCREEN_WIDTH-SIZE_MUR){
         //mur droite
-        sprite->x = (SCREEN_WIDTH*0.9) - sprite->w/2;
+        sprite->x = SCREEN_WIDTH - (SIZE_MUR + sprite->w);
     }
 
-    if (sprite->x < (SCREEN_WIDTH*0.1)){
+    if (sprite->x < SIZE_MUR){
         //mur gauche
-        sprite->x = (SCREEN_WIDTH*0.1);
+        sprite->x = SIZE_MUR;
     }
 
-    if (sprite->y > (SCREEN_HEIGHT*0.9)){
+    if (sprite->y + sprite->h > SCREEN_HEIGHT-SIZE_MUR){
         //mur bas
-        sprite->y = (SCREEN_HEIGHT*0.9) - sprite->w;
+        sprite->y = SCREEN_HEIGHT - (SIZE_MUR + sprite->h);
     }
 
-    if (sprite->y < (SCREEN_HEIGHT*0.1)){
+    if (sprite->y < SIZE_MUR){
         //mur haut
-        sprite->y = (SCREEN_HEIGHT*0.1);
+        sprite->y = SIZE_MUR;
     }
 
 }
@@ -220,26 +275,28 @@ void gestion_events(SDL_Event *event, world_t *world){
                 world->gameover = 1; break;
             //Déplacement du joueur
             case SDLK_UP:
-                deplace_haut(&world->joueur, world);
+            world->joueur.y -= world->joueur.v;
+                //deplace_haut(&world->joueur, world);
                 break;
                 
             case SDLK_DOWN:
-                deplace_bas(&world->joueur, world);
+            world->joueur.y += world->joueur.v;
+                //deplace_bas(&world->joueur, world);
                 break;
 
             case SDLK_RIGHT:
-                deplace_droite(&world->joueur, world);                
+            world->joueur.x += world->joueur.v;
+                //deplace_droite(&world->joueur, world);                
                 break;
                 
             case SDLK_LEFT:
-                deplace_gauche(&world->joueur, world);
+            world->joueur.x -= world->joueur.v;
+                //deplace_gauche(&world->joueur, world);
                 break;
             //case SDLK_SPACE:
             
         }
-    }
-    printf("Sprite joueur : x : %d | y: %d \n", world->joueur.x, world->joueur.y);
-    
+    }    
 }
 
 char** init_map (){
@@ -247,41 +304,42 @@ char** init_map (){
     int hauteur = SCREEN_HEIGHT;
     int largeur = SCREEN_WIDTH;
     char** tab = allouer_tab_2D(hauteur, largeur);
+
     for (int i=0; i<hauteur; i++){
         for (int j=0; j<largeur; j++){
             tab[i][j] = ' '; //Rempli les zones accessibles avec un espaces
 
             //Limites extérieures du terrain remplis avec 'X'
-            if (j< largeur*0.1 || j>= largeur*0.9 || i< hauteur*0.1 || i>= hauteur*0.9){
+            if (j< SIZE_MUR || j>= largeur-SIZE_MUR || i< SIZE_MUR || i>= hauteur-SIZE_MUR){
                 tab[i][j] = 'X';
             }
 
             // Zone de déplacement interdit au joueurs; zones de travail:
-            if((j>=largeur*0.1 && j<largeur*0.2 && i>=hauteur*0.1 && i<hauteur*0.6) || (j>=largeur*0.1 && j<largeur*0.5 && i>=hauteur*0.1 && i<hauteur*0.2 ) || (j>=largeur*0.5 && j<largeur*0.6 && i>=hauteur*0.1 && i<hauteur*0.4)){
+            if((j>= SIZE_MUR && j<BLOC_COMPT_SIZE+SIZE_MUR && i>=SIZE_MUR && i<SIZE_MUR+ (3*BLOC_COMPT_SIZE)) || (j>=SIZE_MUR+BLOC_COMPT_SIZE && j<SIZE_MUR + (4*BLOC_COMPT_SIZE) && i>=SIZE_MUR && i<SIZE_MUR + BLOC_COMPT_SIZE) || (j>= SIZE_MUR + (4*BLOC_COMPT_SIZE) && j< SIZE_MUR + (5*BLOC_COMPT_SIZE) && i>= SIZE_MUR && i<SIZE_MUR + BLOC_COMPT_SIZE*3)){
                 tab[i][j] = 'P';
             }
 
             //Emplacement du frigo
-            if (j>=largeur*0.1 && j<largeur*0.4 && i>=hauteur*0.7 && i<hauteur*0.9){
+            if (j>=SIZE_MUR && j<SIZE_MUR+FRIGO_LARGEUR && i>=hauteur-(SIZE_MUR + FRIGO_HAUTEUR) && i<hauteur - SIZE_MUR){
                 tab[i][j] = 'F';
             }
 
             //Emplacement des fourneaux
-            if (j>=largeur*0.8 && j<largeur*0.9 && i>=hauteur*0.1 && i<hauteur*0.4){
+            if (j>=largeur-(SIZE_MUR+FOUR_HAUTEUR) && j<largeur-SIZE_MUR && i>=SIZE_MUR && i<SIZE_MUR+FOUR_LARGEUR){
                 tab[i][j] = 'f';
             }
 
             //Emplacement du lavabo
-            if (j>=largeur*0.5 && j<largeur*0.8 && i>=hauteur*0.8 && i<hauteur*0.9){
+            if (j>=SIZE_MUR+(4*BLOC_COMPT_SIZE) && j<SIZE_MUR+(4*BLOC_COMPT_SIZE)+LAVABO_LARGEUR && i>=hauteur-(SIZE_MUR+BLOC_COMPT_SIZE) && i<hauteur-(SIZE_MUR+BLOC_COMPT_SIZE)+LAVABO_HAUTEUR){
                 tab[i][j] = 'L';
             }
             //Zone d'envoi
-            if (j>=largeur*0.9 && j<largeur && i>=hauteur*0.5 && i<hauteur*0.7){
+            if (j>=largeur-ZONE_ENVOI_LARGEUR && j<largeur && i>=SIZE_MUR+(3*BLOC_COMPT_SIZE) && i<SIZE_MUR+(3*BLOC_COMPT_SIZE)+ZONE_ENVOI_HAUTEUR){
                 tab[i][j] = 'e';
             }
 
             //Poubelle
-            if (j>=largeur*0.8 && j<largeur*0.9 && i>=hauteur*0.8 && i<hauteur*0.9){
+            if (j>=largeur-(SIZE_MUR+BLOC_COMPT_SIZE) && j<largeur-(SIZE_MUR+BLOC_COMPT_SIZE)+POUBELLE_LARGEUR && i>=hauteur-(SIZE_MUR + POUBELLE_HAUTEUR) && i<hauteur-SIZE_MUR){
                 tab[i][j] = 't';
             }
         }
@@ -295,7 +353,7 @@ void update_data (world_t *world){
     
     limites_externes(&world->joueur, world);
     place_sprite_on_map(&world->joueur, world);
-
+    //printf("Sprite joueur : x : %d | y: %d \n", world->joueur.x, world->joueur.y);
     genere_fichier(nomSave, world->map, SCREEN_HEIGHT, SCREEN_WIDTH);
 }
 

logique.h

@@ -15,6 +15,7 @@
 #include "constantes.h"
 #include "math.h"
 #include "gestion_fichiers.h"
+#include <string.h>
 
 
 /**
@@ -41,6 +42,11 @@ struct world_s{
     int gameover; /*!< Champ indiquant si l'on est à la fin du jeu */
     sprite_t joueur; /*!< Sprite du joueur */
     sprite_t four; /*!< Sprite du four */
+    sprite_t frigo; /*< Sprite du frigo */
+    sprite_t lavabo; /*< Sprite du lavabo */
+    sprite_t envoi; /*< Sprite de la zone d'envoi */
+    sprite_t poubelle; /*< Sprite de la poubelle */
+    sprite_t comptoire[NB_COMPT_1]; /*< Tableau de sprite de comptoir */
     sprite_t plat[NB_PLAT]; /*!< Tableau des sprites type de plats */
     int score; /*!< Score du joueur */
     int compteur_plats; /*!< Nombre d'ennemis étant sorti de l'écran */
@@ -66,6 +72,26 @@ typedef struct world_s world_t;
  */
 void init_sprite(sprite_t *sprite, char nom, int x, int y, int w, int h, int v, int state);
 
+/**
+ * @brief Fonction initialisant un unique sprite (meuble)
+ * 
+ * @param sprite Sprite à initialiser
+ * @param nom Caractère du sprite sur la carte
+ * @param largeur 
+ * @param hauteur 
+ * @param map Carte du jeu, sous forme de tableau de caractère
+ */
+void build_sprite_unique (sprite_t *sprite, char nom, int largeur, int hauteur, char** map);
+
+/**
+ * @brief Fonction initialisant un tableau de sprites
+ * 
+ * @param world données du monde - contenant la map et les spirtes concernés
+ * @param nomSprite Caractère du Sprite sur la carte
+ * @param largeur Largeur du sprite
+ * @param hauteur Hauteur du sprite
+ */
+void build_sprites_tab (world_t* world, char nomSprite, int largeur, int hauteur);
 
 /**
  * \brief la fonction permet de rendre visible un sprite

main.c

@@ -57,7 +57,6 @@ while (estFini(&world)==0){
 }
 
 SDL_Delay(150);
-SDL_DestroyRenderer(ecran);
-SDL_DestroyWindow(windows);
+nettoyage_graphisme(ecran, &textures, windows);
 SDL_Quit();
 }
\ No newline at end of file

tests.c

@@ -85,7 +85,7 @@ void test_limite(){
     SDL_Event event;
     init_data(&world);
     int i=0;
-    while (i<100){
+    while (i<10){
         reset_sprite_on_map(&world.joueur, &world);
 
         gestion_events(&event, &world);
@@ -96,7 +96,7 @@ void test_limite(){
         SDL_Delay(100);
         //afficher_tab_2D(world.map, SCREEN_HEIGHT, SCREEN_WIDTH);
     }
-    afficher_tab_2D(world.map, SCREEN_HEIGHT, SCREEN_WIDTH);
+    //afficher_tab_2D(world.map, SCREEN_HEIGHT, SCREEN_WIDTH);
     SDL_Quit();
 }