graphisme.c 9.14 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
/**
 * \file graphique.h
 * \brief Entête du module des fonctions gérant les graphismes du jeu
 * \author Guillaume Vautrin
 * \version 1.0
 * \date 4 Nobembre 2020
 */

#include "graphisme.h"

void clean_textures(textures_t *textures){
12
13
14
  if (textures->menu != NULL){
    SDL_DestroyTexture(textures->menu);
  }
15
16
17
18
19
20
  if (textures->joueur != NULL){
    SDL_DestroyTexture(textures->joueur);
  }
  if (textures->fond != NULL){
    SDL_DestroyTexture(textures->fond);
  }
21
22
23
  if (textures->comptoire != NULL){
    SDL_DestroyTexture(textures->comptoire);
  }
24
25
  if (textures->envoi != NULL){
    SDL_DestroyTexture(textures->envoi);
26
  }
27
28
  if (textures->frigo != NULL){
    SDL_DestroyTexture(textures->frigo);
29
  }
30
31
  if (textures->four != NULL){
    SDL_DestroyTexture(textures->four);
32
  }
33
34
  if (textures->lavabo != NULL){
    SDL_DestroyTexture(textures->lavabo);
35
36
37
38
  }
  if (textures->poubelle != NULL){
    SDL_DestroyTexture(textures->poubelle);
  }
39
40
41
  if (textures->ingredient != NULL){
    SDL_DestroyTexture(textures->ingredient);
  }
42
43
44
  if (textures->ingredient != NULL){
    TTF_CloseFont(textures->police);
  }
45
46
}

47
48
49
50
51
void nettoyage_graphisme (SDL_Renderer *renderer, textures_t *textures, SDL_Window *fenetre){
  clean_textures(textures);
  SDL_RenderClear(renderer);
  SDL_DestroyWindow(fenetre);
}
52

53
void init_textures (SDL_Renderer *renderer, textures_t *textures, TTF_Font *font){
54
  Uint8 r = 255, g = 255, b = 255;
55
  textures->menu = charger_image("Ressources/menu.bmp", renderer);
56
57
  textures->fond = charger_image("Ressources/fond1.bmp", renderer);
  textures->joueur = charger_image ("Ressources/joueur.bmp", renderer);
58
  textures->comptoire = charger_image ("Ressources/compt0.bmp", renderer);
59
60
61
  textures->envoi = charger_image ("Ressources/envoi0.bmp", renderer);
  textures->frigo = charger_image ("Ressources/frigo0.bmp", renderer);
  textures->four = charger_image ("Ressources/four0.bmp", renderer);
62
  textures->poubelle = charger_image ("Ressources/trash0.bmp", renderer);
63
  textures->lavabo = charger_image ("Ressources/lavabo0.bmp", renderer);
64
  textures->ingredient = charger_image_transparente("Ressources/ingredient.bmp", renderer, r, g, b);
65
  textures->police = font;
66

67
68
  // SDL_Color color = { 255, 0, 255 };
  //... = charger_texte ("Score : ", renderer, font, color);
69
70
}

71
72
void apply_graphics (SDL_Renderer *renderer, textures_t *textures, world_t *world){
  //maj les texture selon la position des éléments différents
73
  //Affichage du fond
74
75
76
  if(textures->fond != NULL){
    SDL_RenderCopy(renderer, textures->fond, NULL, NULL);
  }
77
  //Affichage du joueur
78
  if (textures->joueur !=NULL && est_visible(&world->joueur)){
79
80
    SDL_RenderCopy(renderer, textures->joueur, NULL, &world->joueur.rect);
  }
81
82
83
84
85
86
87
88
89
  apply_mobilier (renderer, textures, world);
  apply_ingredients (renderer, textures, world->en_cuisine);
  apply_texte (renderer, &world->etat_stocks, textures);
}

void apply_mobilier (SDL_Renderer* renderer, textures_t* textures, world_t* world){
  // Affichage des meubles (fixes)

    //Affichage de la poubelle
90
  if (textures->poubelle !=NULL && est_visible(&world->poubelle)){
91
92
    SDL_RenderCopy(renderer, textures->poubelle, NULL, &world->poubelle.rect);
  }
93
  //Affichage du lavabo
94
95
  if (textures->lavabo !=NULL && est_visible(&world->lavabo)){
    SDL_RenderCopy(renderer, textures->lavabo, NULL, &world->lavabo.rect);
96
  }
97
  //Affichage du frigo
98
99
  if (textures->frigo !=NULL&& est_visible(&world->frigo)){
    SDL_RenderCopy(renderer, textures->frigo, NULL, &world->frigo.rect);
100
  }
101
  //Affichage du four
102
103
  if (textures->four !=NULL && est_visible(&world->four)){
    SDL_RenderCopy(renderer, textures->four, NULL, &world->four.rect);
104
  }
105
  //Affichage de la zone d'envoi
106
107
  if (textures->envoi !=NULL && est_visible(&world->envoi)){
    SDL_RenderCopy(renderer, textures->envoi, NULL, &world->envoi.rect);
108
  }
109
  //Affichage des comptoires
110
111
112
113
114
115
116
  if (textures->comptoire != NULL){
    for (int i=0; i<NB_COMPT_1; i++){
      if (est_visible(&world->comptoire[i])){
        SDL_RenderCopy(renderer, textures->comptoire, NULL, &world->comptoire[i].rect);
      }
    }
  }
117
118
119
}

void apply_ingredients (SDL_Renderer* renderer, textures_t* textures, sprite_t* ingredients){
120
  //Affichage des ingrédients
121
122
123
  SDL_Rect temp;
  if (textures->ingredient !=NULL){
    for (int i=0; i<NB_INGREDIENT; i++){
124
      if (est_visible(&ingredients[i])){
125
126

        //Afficher la texture approprié au sprite détecté
127
128
        char name = ingredients[i].nom;
        switch(name){
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
          case NOM_TOMATE:
            temp = create_SDL_rect_from_texture(textures->ingredient, 0, 0, PLAT_SIZE, PLAT_SIZE);
            break;

          case NOM_PAIN:
            temp = create_SDL_rect_from_texture(textures->ingredient, 25, 0, PLAT_SIZE, PLAT_SIZE);
            break;

          case NOM_STEAK:
            temp = create_SDL_rect_from_texture(textures->ingredient, 50, 0, PLAT_SIZE, PLAT_SIZE);
            break;

          case NOM_SALADE:
            temp = create_SDL_rect_from_texture(textures->ingredient, 75, 0, PLAT_SIZE, PLAT_SIZE);
            break;
          
          case NOM_FROMAGE:
            temp = create_SDL_rect_from_texture(textures->ingredient, 100, 0, PLAT_SIZE, PLAT_SIZE);
            break;
          
          case NOM_CORNICHON:
            temp = create_SDL_rect_from_texture(textures->ingredient, 125, 0, PLAT_SIZE, PLAT_SIZE);
            break;
        }
153
154
        SDL_Rect* rectangle = &ingredients[i].rect;
        SDL_RenderCopy(renderer, textures->ingredient, &temp, rectangle);
155
156
157
      }
    }
  }
158
}
159

160
161
void apply_texte (SDL_Renderer* renderer, stock_t* stock, textures_t* textures){
    //Affichage du score
162
163
164
165
  if (textures->police != NULL){
    //Zone d'affichage du score -- taille du score s'adapte à son contenu
    SDL_Rect zone_message = create_SDL_rect(20, 550, 75, 50);
    SDL_Rect zone_score;
166
    if (get_score(stock)<100){
167
      zone_score = create_SDL_rect(90, 555, 40, 40);
168
    }else if (get_score(stock)<10000){
169
170
171
172
      zone_score = create_SDL_rect(90, 555, 60, 40);
    }else{
      zone_score = create_SDL_rect(90, 555, 100, 40);
    }
173
    //Couleur du texte
174
175
176
    SDL_Color color = { 255, 255, 0, 0 };
    SDL_Texture* message;
    SDL_Texture* points;
177
    //affichage en deux partie de score et de la valeur du score
178
179
    message = charger_texte("Score : ", renderer, textures->police, color);
    char score_j[10];
180
181
    sprintf(score_j, " %d", stock->score); //Nécessaire pour afficher le score -- limite le nombre de points max!
    printf("\n SCORE : %d", get_score(stock));
182
183
184
185
    points = charger_texte(score_j, renderer, textures->police, color);
    render_texte(renderer, zone_message, message);
    render_texte(renderer, zone_score, points);
  }
186
187
}

188
SDL_Rect create_SDL_rect_from_texture (SDL_Texture * texture, int x, int y, int h, int w){
189
  //Permet de créer un SDL_rect retournant la texture de la taille de la texture (SOURCE)
190
191
192
193
194
195
196
197
  int largeur;
  int hauteur;
  SDL_QueryTexture(texture, NULL, NULL, &largeur, &hauteur);
  if (h>hauteur || w>largeur || h<=0 || w<=0){
    SDL_Rect temp = {0,0,0,0};
    return temp;
  }
  return create_SDL_rect (x, y, w, h);
198
}
199

200
SDL_Rect create_SDL_rect (int x, int y, int w, int h){
201
    //permet de créer un SDL_rect en connaissant déjà les coordonnées
202
203
204
205
206
    SDL_Rect rectangle;
    rectangle.x = x;
    rectangle.y = y;
    rectangle.w = w;
    rectangle.h = h;
207
    return rectangle;
208
}
209

210
211
212

void update_graphics (SDL_Renderer *renderer, world_t *world, textures_t *textures){

213
  SDL_RenderClear(renderer); // permet de vider le Renderer (ecran) de toutes les textures
214
  apply_graphics(renderer, textures, world);
215
  SDL_RenderPresent(renderer); // Récupère les infos actualisés de render et les affiches
216

217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
}

SDL_Texture* charger_image (const char* nomfichier, SDL_Renderer* renderer){
    //Charge une image et retourne la surface de texture associée
    SDL_Surface * image = SDL_LoadBMP(nomfichier);
    SDL_Texture *texture = SDL_CreateTextureFromSurface(renderer, image);
    SDL_FreeSurface(image);
    return texture;
}

SDL_Texture* charger_image_transparente(const char* nomfichier, SDL_Renderer* renderer, Uint8 r, Uint8 g, Uint8 b){
    SDL_Surface * image = SDL_LoadBMP(nomfichier);
    SDL_SetColorKey(image, SDL_TRUE, SDL_MapRGB(image->format, r, g, b));
    SDL_Texture* texture = SDL_CreateTextureFromSurface(renderer, image);
    SDL_FreeSurface(image);
    return texture;
}
//int SDL_SetColorKey(SDL_Surface* surface, int flag, Uint32 key) ; // défini la couleur transparente dans une surface

//Uint32 SDL_MapRGB(const SDL_PixelFormat* format, Uint8 r, Uint8 g, Uint8 b); //map les couleurs d'une bitmap

SDL_Texture* charger_texte (const char* message, SDL_Renderer* renderer, TTF_Font *font, SDL_Color color){
    SDL_Surface* texte = TTF_RenderText_Blended(font, message, color);
    SDL_Texture* texture = SDL_CreateTextureFromSurface(renderer, texte);
    SDL_FreeSurface(texte);
    return texture;
}

245
246
void render_texte(SDL_Renderer *renderer, SDL_Rect zone_texte, SDL_Texture* texte){
    SDL_RenderCopy(renderer, texte, NULL, &zone_texte);
247
248
249
250
251
252
253
254
255
}

/*
TTF_Font *TTF_OpenFont(const char *file, int size) ; //charge la police et applique la taille du texte
// Écrire le texte sur une surface SDL
SDL_Surface *TTF_RenderText_Solid(TTF_Font *font, const char *text, SDL_Color fg) ;
// Fermer la police
void TTF_CloseFont(TTF_Font *font) ;
*/