Commit 73a62e2b authored by vautrin33u's avatar vautrin33u
Browse files

Timers et mouvements ajustés + redécoupage en module

parent 4bf77fcb
......@@ -5,8 +5,8 @@ LDFLAGS = `sdl2-config --cflags --libs` -lSDL2_ttf
INCLUDES = -I./SDL2_ttf
EXEC1 = main
EXEC2 = tests
SRC = logique.c gestion_fichiers.c sprite.c stocks.c graphisme.c main.c
SRC2 = logique.c gestion_fichiers.c sprite.c stocks.c graphisme.c tests.c
SRC = gestion_fichiers.c sprite.c stocks.c interactions.c logique.c graphisme.c main.c
SRC2 = gestion_fichiers.c sprite.c stocks.c interactions.c logique.c graphisme.c tests.c
OBJ = $(SRC:.c=.o)
OBJ2 = $(SRC2:.c=.o)
......
This source diff could not be displayed because it is too large. You can view the blob instead.
......@@ -79,7 +79,7 @@ void apply_graphics (SDL_Renderer *renderer, textures_t *textures, world_t *worl
SDL_RenderCopy(renderer, textures->joueur, NULL, &world->joueur.rect);
}
apply_mobilier (renderer, textures, world);
apply_ingredients (renderer, textures, world->en_cuisine);
apply_ingredients (renderer, textures, world->etat_stocks.commande_actuelle, world->etat_stocks.nb);
apply_texte (renderer, world, textures);
}
......@@ -116,11 +116,11 @@ void apply_mobilier (SDL_Renderer* renderer, textures_t* textures, world_t* worl
}
}
void apply_ingredients (SDL_Renderer* renderer, textures_t* textures, sprite_t* ingredients){
void apply_ingredients (SDL_Renderer* renderer, textures_t* textures, sprite_t* ingredients, int taille_commande){
//Affichage des ingrédients
SDL_Rect temp;
if (textures->ingredient !=NULL){
for (int i=0; i<NB_INGREDIENT; i++){
for (int i=0; i<taille_commande; i++){
if (est_visible(&ingredients[i])){
char name = ingredients[i].nom;
if (get_cuisson(&ingredients[i]) != CUIT && get_cuisson(&ingredients[i]) != PROPRE){
......
......@@ -105,8 +105,9 @@ void apply_texte (SDL_Renderer* renderer, world_t* world, textures_t* textures);
* @param renderer
* @param textures textures du jeu
* @param ingredients données concernant les ingrédients en jeu
* @param taille_commande taille de la commande actuelle
*/
void apply_ingredients (SDL_Renderer* renderer, textures_t* textures, sprite_t* ingredients);
void apply_ingredients (SDL_Renderer* renderer, textures_t* textures, sprite_t* ingredients, int taille_commande);
/**
* @brief Créer un objet SDL_rect
......
/**
* \file interactions.c
* \brief Source code module interactions.c
* \author Guillaume Vautrin
* \version 1.0
* \date 29 Decembre 2020
*/
#include "interactions.h"
void interaction_frigo (sprite_t* ingredients, sprite_t* joueur, sprite_t* frigo, int taille_commande){
for (int i=0; i<taille_commande; i++){
//Interaction avec le frigo (récupérer les éléments un par un)
if (has_collided(frigo, &ingredients[i]) && return_state(&ingredients[i]) == POSE && is_already_carrying(ingredients, taille_commande)==SDL_FALSE){
set_portable(&ingredients[i]);
set_visible(&ingredients[i]);
init_cuisson(&ingredients[i]);
handle_deplacement_ingredient(joueur, &ingredients[i]);
break;
}
}
}
void interaction_poser (sprite_t* ingredients, sprite_t* joueur, sprite_t* meuble, int taille_commande){
for (int i=0; i<taille_commande; i++){
if (has_collided(joueur, &ingredients[i]) && return_state(&ingredients[i]) == PORTE && ((meuble->nom == NOM_FOUR && get_cuisson(&ingredients[i]) == CRU) || (meuble->nom == NOM_LAVABO && get_cuisson(&ingredients[i]) == SALE) || (meuble->nom == MARQUEUR_COMPT))) {
//On pose un ingrédient et on change l'état si nécessaire
poser_ingredient(joueur, meuble, &ingredients[i]);
if (meuble->nom == NOM_FOUR){
ingredients[i].debut_timer = SDL_GetTicks();
}
if (meuble->nom == NOM_LAVABO){
ingredients[i].debut_timer = SDL_GetTicks();
}
if (meuble->nom == NOM_COMPT) set_cuisson(&ingredients[i], get_cuisson(&ingredients[i]));
if (burger_est_complet(ingredients, taille_commande) == SDL_FALSE){
break;
}
}
}
}
void interaction_reprendre (sprite_t* ingredients, sprite_t* joueur, sprite_t* meuble, int taille_commande){
for (int i=0; i<taille_commande; i++){
if (has_interaction(joueur, &ingredients[i]) && return_state(&ingredients[i]) == POSE ){ //&& (get_cuisson(&ingredients[i]) == cuisson_attendue || meuble->nom == MARQUEUR_COMPT)
set_portable(&ingredients[i]);
ingredients[i].debut_timer = 0;
handle_deplacement_ingredient(joueur, &ingredients[i]);
if (burger_est_complet(ingredients, taille_commande) == SDL_FALSE && meuble->nom != MARQUEUR_COMPT){
break;
}
}
}
}
void interaction_poubelle (sprite_t* ingredients, sprite_t* joueur, SDL_Rect zone_reset, int taille_commande){
for (int i=0; i<taille_commande; i++){
if (has_collided(joueur, &ingredients[i]) && return_state(&ingredients[i]) == PORTE && is_already_carrying(ingredients, taille_commande)==SDL_TRUE){
//On pose un ingrédient pour le jeter et le replacer dans le frigo
char copy = ingredients[i].nom;
init_ingre(&ingredients[i], copy, zone_reset.x, zone_reset.y, PLAT_SIZE, PLAT_SIZE, 0, POSE);
break;
}
}
}
void poser_ingredient (sprite_t* joueur, sprite_t* meuble, sprite_t* ingredient){
//Pose l'ingrédient sur un meuble
switch (return_state(joueur))
{
case HAUT:
ingredient->rect.y = meuble->rect.y + meuble->rect.h - ingredient->rect.h;
//Gestion des positions horizontales de l'ingrédient pour qu'il reste sur le meuble
if (ingredient->rect.x < meuble->rect.x) {
ingredient->rect.x = meuble->rect.x;
}else if (ingredient->rect.x + ingredient->rect.w > meuble->rect.x + meuble->rect.w){
ingredient->rect.x = meuble->rect.x + meuble->rect.w - ingredient->rect.w;
}
break;
case BAS:
ingredient->rect.y = meuble->rect.y;
//Gestion des positions horizontales de l'ingrédient pour qu'il reste sur le meuble
if (ingredient->rect.x < meuble->rect.x) {
ingredient->rect.x = meuble->rect.x;
}else if (ingredient->rect.x + ingredient->rect.w > meuble->rect.x + meuble->rect.w){
ingredient->rect.x = meuble->rect.x + meuble->rect.w - ingredient->rect.w;
}
break;
case GAUCHE:
ingredient->rect.x = meuble->rect.x + meuble->rect.w - ingredient->rect.w;
//Gestion des positions verticales de l'ingrédient pour qu'il reste sur le meuble
if (ingredient->rect.y < meuble->rect.y) {
ingredient->rect.y = meuble->rect.y;
}else if (ingredient->rect.y + ingredient->rect.h > meuble->rect.y + meuble->rect.h){
ingredient->rect.y = meuble->rect.y + meuble->rect.h - ingredient->rect.h;
}
break;
case DROITE:
ingredient->rect.x = meuble->rect.x;
//Gestion des positions verticales de l'ingrédient pour qu'il reste sur le meuble
if (ingredient->rect.y < meuble->rect.y) {
ingredient->rect.y = meuble->rect.y;
}else if (ingredient->rect.y + ingredient->rect.h > meuble->rect.y + meuble->rect.h){
ingredient->rect.y = meuble->rect.y + meuble->rect.h - ingredient->rect.h;
}
break;
default:
break;
}
set_posee(ingredient);
}
SDL_bool is_already_carrying (sprite_t* ingredients, int taille_commande){
//Vérifie si un ingrédient n'est pas déjà porté
for (int i=0; i<taille_commande; i++){
if (return_state(&ingredients[i]) == PORTE){
return SDL_TRUE;
}
}
return SDL_FALSE;
}
SDL_bool burger_est_complet (sprite_t* ingredients, int taille_commande){
//Vérifie si le burger est bien complet
int compt=1;
SDL_Rect temp1;
SDL_Rect temp2;
for (int i=0; i<taille_commande; i++){
temp1 = get_rect(&ingredients[i]);
temp2 = get_rect(&ingredients[i+1]);
if (get_cuisson(&ingredients[i]) != FRIGO && get_cuisson(&ingredients[i+1]) != FRIGO && temp1.x == temp2.x && temp1.y == temp2.y) {
compt++;
}
}
if (compt==taille_commande){
return SDL_TRUE;
}
return SDL_FALSE;
}
void handle_deplacement_ingredient (sprite_t* joueur, sprite_t* ingredient){
//Gestion du déplacement d'un ingrédient par rapport au joueur
if (return_state(ingredient) == PORTE){
SDL_Rect pos_ingredient = get_rect(ingredient);
SDL_Rect pos_joueur = get_rect(joueur);
switch (return_state(joueur)){
case BAS:
ingredient->rect.x = (pos_joueur.x+(pos_joueur.w/2)) - pos_ingredient.w/2;
ingredient->rect.y = (pos_joueur.y + pos_joueur.h) - pos_ingredient.h;
break;
case HAUT:
ingredient->rect.x = (pos_joueur.x+(pos_joueur.w/2)) - pos_ingredient.w/2;
ingredient->rect.y = pos_joueur.y;
break;
case DROITE:
ingredient->rect.x = (pos_joueur.x + pos_joueur.w) - pos_ingredient.w;
ingredient->rect.y = (pos_joueur.y+(pos_joueur.h/2)) - pos_ingredient.h/2;
break;
case GAUCHE:
ingredient->rect.x = pos_joueur.x;
ingredient->rect.y = (pos_joueur.y+(pos_joueur.h/2)) - pos_ingredient.h/2;
break;
}
}
}
/**
* \file interactions.h
* \brief Entête du module interactions.c
* \author Guillaume Vautrin
* \version 1.0
* \date 29 Decembre 2020
*/
#ifndef INTERACTIONS_H
#define INTERACTIONS_H
#include "stocks.h"
/**
* @brief Interaction avec la poubelle
*
* @param ingredients Tous les ingrédients disponibles sur le jeu
* @param joueur
* @param zone_reset SDL_Rect correspondant à la zone de départ des ingrédients
*/
void interaction_poubelle (sprite_t* ingredients, sprite_t* joueur, SDL_Rect zone_reset, int taille_commande);
/**
* @brief Reprends l'objet posé sur un sprite, limité par son état de cuisson
*
* @param ingredients
* @param joueur
* @param cuisson_attendue cuisson attendue avant de pouvoir récupérer l'objet
*/
void interaction_reprendre (sprite_t* ingredients, sprite_t* joueur, sprite_t* meuble, int taille_commande);
/**
* @brief Poser dans le four un ingrédient
*
* @param ingredients
* @param joueur
* @param four
*/
void interaction_poser (sprite_t* ingredients, sprite_t* joueur, sprite_t* meuble, int taille_commande);
/**
* @brief Génère les ingrédients
*
* @param ingredients
* @param joueur
* @param frigo
*/
void interaction_frigo (sprite_t* ingredients, sprite_t* joueur, sprite_t* frigo, int taille_commande);
/**
* @brief Pose un ingrédient sur un meuble
*
* @param joueur
* @param meuble
* @param ingredient
*/
void poser_ingredient (sprite_t* joueur, sprite_t* meuble, sprite_t* ingredient);
/**
* @brief Vérifie si un ingrédient et déjà porté ou non
*
* @param ingredients
* @return SDL_bool
*/
SDL_bool is_already_carrying (sprite_t* ingredients, int taille_commande);
/**
* @brief Vérifie que le burger est complet (selon sa position)
*
* @param ingredients tous les ingrédients disponible en cours
* @return SDL_bool
*/
SDL_bool burger_est_complet (sprite_t* ingredients, int taille_commande);
/**
* @brief Déplace un ingrédient tant que le joueur le porte
*
* @param joueur
* @param ingredient
*/
void handle_deplacement_ingredient (sprite_t* joueur, sprite_t* ingredient);
#endif
\ No newline at end of file
......@@ -34,46 +34,8 @@ void init_data(world_t * world){
}
//initialise la structure stock (menu, score et tableau de commande)
init_stocks(&world->etat_stocks, &world->frigo);
init_stocks(&world->etat_stocks, get_rect(&world->frigo));
//Initialisation du tableau de recette disponible en cuisine selon le tableau de commande
init_ingredient_cuisine(world, &world->etat_stocks);
}
void init_ingredient_cuisine(world_t * world, stock_t *stocks){
//initialisation des ingrédients mise à disposition en cuisine, selon la commande du client
int compt_tomate = 0;
int compt_salade = 0;
int compt_steak = 0;
int compt_cornichon = 0;
int compt_fromage = 0;
world->en_cuisine[0] = stocks->stock_pain[0];
world->en_cuisine[INGREDIENT_DISPO-1] = stocks->stock_pain[1];
for (int i=1; i<INGREDIENT_DISPO-1; i++){
switch (stocks->commande[i]){
case NOM_TOMATE:
world->en_cuisine[i] = stocks->stock_tomate[compt_tomate];
compt_tomate++;
break;
case NOM_SALADE:
world->en_cuisine[i] = stocks->stock_salade[compt_salade];
compt_salade++;
break;
case NOM_STEAK:
world->en_cuisine[i] = stocks->stock_steak[compt_steak];
compt_steak++;
break;
case NOM_CORNICHON:
world->en_cuisine[i] = stocks->stock_cornichon[compt_cornichon];
compt_cornichon++;
break;
default:
world->en_cuisine[i] = stocks->stock_fromage[compt_fromage];
compt_fromage++;
break;
}
}
}
......@@ -108,34 +70,6 @@ void handle_collision (sprite_t* spr_move, sprite_t* spr_fixed){
}
}
void handle_deplacement_ingredient (sprite_t* joueur, sprite_t* ingredient){
//Gestion du déplacement d'un ingrédient par rapport au joueur
if (return_state(ingredient) == PORTE){
SDL_Rect pos_ingredient = get_rect(ingredient);
SDL_Rect pos_joueur = get_rect(joueur);
switch (return_state(joueur)){
case BAS:
ingredient->rect.x = (pos_joueur.x+(pos_joueur.w/2)) - pos_ingredient.w/2;
ingredient->rect.y = (pos_joueur.y + pos_joueur.h) - pos_ingredient.h;
break;
case HAUT:
ingredient->rect.x = (pos_joueur.x+(pos_joueur.w/2)) - pos_ingredient.w/2;
ingredient->rect.y = pos_joueur.y;
break;
case DROITE:
ingredient->rect.x = (pos_joueur.x + pos_joueur.w) - pos_ingredient.w;
ingredient->rect.y = (pos_joueur.y+(pos_joueur.h/2)) - pos_ingredient.h/2;
break;
case GAUCHE:
ingredient->rect.x = pos_joueur.x;
ingredient->rect.y = (pos_joueur.y+(pos_joueur.h/2)) - pos_ingredient.h/2;
break;
}
}
}
int estFini(world_t *world){
//Défini si le jeu est terminé
return world->gameover;
......@@ -176,9 +110,9 @@ void limites_interne (world_t* world){
handle_collision(&world->joueur, &world->comptoire[i]);
}
//Déplacement d'un ingrédient avec le joueur;
for (int i=0; i<INGREDIENT_DISPO; i++){
if (return_state(&world->en_cuisine[i]) == PORTE){
handle_deplacement_ingredient(&world->joueur, &world->en_cuisine[i]);
for (int i=0; i<world->etat_stocks.nb; i++){
if (return_state(&world->etat_stocks.commande_actuelle[i]) == PORTE){
handle_deplacement_ingredient(&world->joueur, &world->etat_stocks.commande_actuelle[i]);
}
}
}
......@@ -205,6 +139,8 @@ void place_sprite_on_map (sprite_t *sprite, world_t *world){ //TODO: A retravail
void gestion_events(SDL_Event *event, world_t *world){
int temp = world->joueur.v;
sprite_t* commande = world->etat_stocks.commande_actuelle;
int nb_ingredients = world->etat_stocks.nb;
SDL_PollEvent(event);
switch(event->type){
case SDL_QUIT:
......@@ -236,41 +172,43 @@ void gestion_events(SDL_Event *event, world_t *world){
break;
case SDLK_SPACE: // POUR POSER DES OBJETS
if (has_interaction (&world->joueur, &world->frigo)){
interaction_frigo(world->en_cuisine, &world->joueur, &world->frigo);
interaction_frigo(commande, &world->joueur, &world->frigo, nb_ingredients);
}
if (has_interaction(&world->joueur, &world->four)){
interaction_poser(world->en_cuisine, &world->joueur, &world->four);
interaction_poser(commande, &world->joueur, &world->four, nb_ingredients);
}
if (has_interaction(&world->joueur, &world->poubelle)){
interaction_poubelle(world->en_cuisine, &world->joueur, get_rect(&world->frigo));
interaction_poubelle(commande, &world->joueur, get_rect(&world->frigo), nb_ingredients);
}
if (has_interaction(&world->joueur, &world->lavabo)){
interaction_poser (world->en_cuisine, &world->joueur, &world->lavabo);
interaction_poser (commande, &world->joueur, &world->lavabo, nb_ingredients);
}
if (has_interaction(&world->joueur, &world->envoi)){
interaction_zone_envoi(world, world->en_cuisine, &world->joueur, &world->envoi);
interaction_zone_envoi(world, commande, &world->joueur, &world->envoi, nb_ingredients);
}
//Interaction avec les comptoirs
for (int i=0; i<NB_COMPT_1; i++){
if (has_interaction(&world->joueur, &world->comptoire[i])){
interaction_poser(world->en_cuisine, &world->joueur, &world->comptoire[i]);
interaction_poser(commande, &world->joueur, &world->comptoire[i], nb_ingredients);
}
}
break;
case SDLK_RETURN: // Cas pour récupérer des objets
if (is_already_carrying (world->en_cuisine)==SDL_FALSE){
if (is_already_carrying (commande, nb_ingredients)==SDL_FALSE){
if (has_interaction(&world->joueur, &world->four)){
interaction_reprendre (world->en_cuisine, &world->joueur, &world->four, CUIT);
interaction_reprendre (commande, &world->joueur, &world->four, nb_ingredients);
}
if (has_interaction(&world->joueur, &world->lavabo)){
interaction_reprendre (world->en_cuisine, &world->joueur, &world->lavabo, PROPRE);
interaction_reprendre (commande, &world->joueur, &world->lavabo, nb_ingredients);
}
for (int i=0; i<NB_COMPT_1; i++){
if (has_interaction(&world->joueur, &world->comptoire[i])){
interaction_reprendre (world->en_cuisine, &world->joueur, &world->comptoire[i], PROPRE);
interaction_reprendre (commande, &world->joueur, &world->comptoire[i], nb_ingredients);
}
}
}
......@@ -280,161 +218,32 @@ void gestion_events(SDL_Event *event, world_t *world){
}
}
void interaction_frigo (sprite_t* ingredients, sprite_t* joueur, sprite_t* frigo){
for (int i=0; i<INGREDIENT_DISPO; i++){
//Interaction avec le frigo (récupérer les éléments un par un)
if (has_collided(frigo, &ingredients[i]) && return_state(&ingredients[i]) == POSE && is_already_carrying(ingredients)==SDL_FALSE){
set_portable(&ingredients[i]);
set_visible(&ingredients[i]);
init_cuisson(&ingredients[i]);
handle_deplacement_ingredient(joueur, &ingredients[i]);
break;
}
}
}
void interaction_zone_envoi (world_t* world, sprite_t* ingredients, sprite_t* joueur, sprite_t* envoi){
for (int i=0; i<INGREDIENT_DISPO; i++){
void interaction_zone_envoi (world_t* world, sprite_t* ingredients, sprite_t* joueur, sprite_t* envoi, int taille_commande){
for (int i=0; i<taille_commande; i++){
if (has_interaction(joueur, envoi) && has_collided(joueur, &ingredients[i]) && return_state(&ingredients[i]) == PORTE){
//On pose un ingrédient sur la zone d'envoi, calcul du score ET on réinitialise
if (burger_est_complet(ingredients)){
if (burger_est_complet(ingredients, taille_commande)){
//On pose le burger entièrement et on calcul le score
for (int i=0; i<INGREDIENT_DISPO; i++){
set_posee(&world->en_cuisine[i]);
for (int i=0; i<taille_commande; i++){
set_posee(&ingredients[i]);
calcul_score(world, &ingredients[i]);
//Réinitialisation du sprite
SDL_Rect temp = get_rect(&world->frigo);
char copy = ingredients[i].nom;
init_ingre(&ingredients[i], copy, temp.x, temp.y, PLAT_SIZE, PLAT_SIZE, 0, POSE);
}
world->compteur_plats++;
free_tab_commande(&world->etat_stocks);
init_tab_commande(&world->etat_stocks);
init_commande_client (&world->etat_stocks, get_rect(&world->frigo));
}
break;
}
}
}
void interaction_poser (sprite_t* ingredients, sprite_t* joueur, sprite_t* meuble){
for (int i=0; i<INGREDIENT_DISPO; i++){
if (has_collided(joueur, &ingredients[i]) && return_state(&ingredients[i]) == PORTE && ((meuble->nom == NOM_FOUR && get_cuisson(&ingredients[i]) == CRU) || (meuble->nom == NOM_LAVABO && get_cuisson(&ingredients[i]) == SALE) || (meuble->nom == MARQUEUR_COMPT))) {
//On pose un ingrédient et on change l'état si nécessaire
poser_ingredient(joueur, meuble, &ingredients[i]);
if (meuble->nom == NOM_FOUR) set_cuisson(&ingredients[i], CUIT);
if (meuble->nom == NOM_LAVABO) set_cuisson(&ingredients[i], PROPRE);
if (meuble->nom == NOM_COMPT) set_cuisson(&ingredients[i], get_cuisson(&ingredients[i]));
if (burger_est_complet(ingredients) == SDL_FALSE){
break;
}
}
}
}
void interaction_reprendre (sprite_t* ingredients, sprite_t* joueur, sprite_t* meuble, int cuisson_attendue){
for (int i=0; i<INGREDIENT_DISPO; i++){
if (has_interaction(joueur, &ingredients[i]) && return_state(&ingredients[i]) == POSE && (get_cuisson(&ingredients[i]) == cuisson_attendue || meuble->nom == MARQUEUR_COMPT)){
set_portable(&ingredients[i]);
handle_deplacement_ingredient(joueur, &ingredients[i]);
if (burger_est_complet(ingredients) == SDL_FALSE && meuble->nom != MARQUEUR_COMPT){
break;
}
}
}
}
void interaction_poubelle (sprite_t* ingredients, sprite_t* joueur, SDL_Rect zone_reset){
for (int i=0; i<INGREDIENT_DISPO; i++){
if (has_collided(joueur, &ingredients[i]) && return_state(&ingredients[i]) == PORTE && is_already_carrying(ingredients)==SDL_TRUE){
//On pose un ingrédient pour le jeter et le replacer dans le frigo
char copy = ingredients[i].nom;
init_ingre(&ingredients[i], copy, zone_reset.x, zone_reset.y, PLAT_SIZE, PLAT_SIZE, 0, POSE);
break;
}
}
}
void poser_ingredient (sprite_t* joueur, sprite_t* meuble, sprite_t* ingredient){
//Pose l'ingrédient sur un meuble
switch (return_state(joueur))
{
case HAUT:
ingredient->rect.y = meuble->rect.y + meuble->rect.h - ingredient->rect.h;
//Gestion des positions horizontales de l'ingrédient pour qu'il reste sur le meuble
if (ingredient->rect.x < meuble->rect.x) {
ingredient->rect.x = meuble->rect.x;
}else if (ingredient->rect.x + ingredient->rect.w > meuble->rect.x + meuble->rect.w){
ingredient->rect.x = meuble->rect.x + meuble->rect.w - ingredient->rect.w;
}
break;
case BAS:
ingredient->rect.y = meuble->rect.y;
//Gestion des positions horizontales de l'ingrédient pour qu'il reste sur le meuble
if (ingredient->rect.x < meuble->rect.x) {
ingredient->rect.x = meuble->rect.x;
}else if (ingredient->rect.x + ingredient->rect.w > meuble->rect.x + meuble->rect.w){
ingredient->rect.x = meuble->rect.x + meuble->rect.w - ingredient->rect.w;
}
break;
case GAUCHE:
ingredient->rect.x = meuble->rect.x + meuble->rect.w - ingredient->rect.w;
//Gestion des positions verticales de l'ingrédient pour qu'il reste sur le meuble
if (ingredient->rect.y < meuble->rect.y) {
ingredient->rect.y = meuble->rect.y;
}else if (ingredient->rect.y + ingredient->rect.h > meuble->rect.y + meuble->rect.h){
ingredient->rect.y = meuble->rect.y + meuble->rect.h - ingredient->rect.h;
}
break;
case DROITE:
ingredient->rect.x = meuble->rect.x;
//Gestion des positions verticales de l'ingrédient pour qu'il reste sur le meuble
if (ingredient->rect.y < meuble->rect.y) {
ingredient->rect.y = meuble->rect.y;
}else if (ingredient->rect.y + ingredient->rect.h > meuble->rect.y + meuble->rect.h){
ingredient->rect.y = meuble->rect.y + meuble->rect.h - ingredient->rect.h;
}
break;
default:
break;
}