logique.h

/**
 * \file logique.h
 * \brief Entête du module logique.c
 * \author Erwan FINEL et Guillaume Vautrin
 * \version 1.0
 * \date 2 Avril 2020
 */

#ifndef LOGIQUE_H
#define LOGIQUE_H

#include <SDL2/SDL.h>
#include <SDL2/SDL_ttf.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "constantes.h"
#include "math.h"
#include "gestion_fichiers.h"
#include <string.h>


/**
 * \brief Representation d'un sprite
 */
struct sprite_s{
    char nom; /*!<  char du sprite utilisé sur map*/
    int v; /*!< vitesse du sprite*/
    int etat; /*!< état du sprite; permet de varier son apparence */
    int is_visible; /*!<  Gère la visibilité d'un sprite; 1 si visible, 0 sinon */
    SDL_Rect rect; /*!<  structure de position du sprite*/
    int cuisson; /*!< Etat de la cuisson*/
};

/**
 * \brief Type qui correspond au sprite
 */

typedef struct sprite_s sprite_t;


/**
 * \brief Representation des stocks, du menu commandé par le client, et du score.
 */
struct stock_s{
    sprite_t stock_tomate[QTE_STOCK]; /*!<  stock de tomates*/
    sprite_t stock_pain[2];  /*!< stock de pains*/
    sprite_t stock_steak[QTE_STOCK];  /*!<  stock de steaks*/
    sprite_t stock_salade[QTE_STOCK];  /*!<  stock de salade*/
    sprite_t stock_fromage[QTE_STOCK];  /*!<  stock de fromage*/
    sprite_t stock_cornichon[QTE_STOCK];  /*!<  stock de cornichon*/
    int score;  /*!<  Score actuel*/
    char commande[5]; /*!< tableau correspondant à un plat à faire*/
};
/**
 * \brief Type qui correspond au menu et aux stocks
 */
typedef struct stock_s stock_t;

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 en_cuisine[INGREDIENT_DISPO]; /*< Tableau d'ingrédients */
    stock_t etat_stocks;  /*!< Structure gérant les stocks et le score*/
    int compteur_plats; /*!< Nombre d'ennemis étant sorti de l'écran */
    int attente; /*!< Compte le nombre de tours avant la fin de la partie*/
    char** map; /*!< tableau de caractère correspondant à l'état de la map actuel */
};

/**
 * \brief Type qui correspond aux données du monde
 */
typedef struct world_s world_t;

/**
 * \brief La fonction initialise un sprite
 * \param sprite pointeur vers le sprite à initialiser
 * \param nom charactère représentant le sprite sur la map
 * \param x gestion de la localisation sur l'axe des abscisses
 * \param y gestion de la localisation sur l'axe des ordonnés
 * \param w largeur du sprite
 * \param h hauteur du sprite
 * \param v vitesse du sprite
 * \param state état du sprite
 */
void init_sprite(sprite_t *sprite, char nom, int x, int y, int w, int h, int v, int state);

/**
 * @brief Initialise un ingrédient et son sprite
 * 
 * @param ingre pointeur vers le sprite d'un ingrédient à initialiser
 * @param nom Caractère représentant l'ingredient sur la map
 * @param x Localisation sur l'axe des abscisses
 * @param y Localisation sur l'axe des ordonnées
 * @param w Largeur
 * @param h Hauteur
 * @param v Vitesse
 * @param state Etat du sprite
 */
void init_ingre (sprite_t* ingre, char nom, int x, int y, int w, int h, int v, int state);

/**
 * @brief Initialise les stocks et l'état de complétion des burgers
 * 
 * @param stocks Etat des stocks
 * @param world Données du monde
 */
void init_stocks(stock_t* stocks, sprite_t* zone_stockage);

/**
 * @brief Initialise le tableau de commande
 * @param stocks 
 */
void init_commande(stock_t *stocks);

/**
 * @brief Génère les sprites rendu disponible selon le bon de commande actuel
 * @param world Données du monde du jeu
 * @param stocks Données des ingrédients en stock / commande / score
 */
void init_ingredient_cuisine(world_t * world, stock_t *stocks);

/**
 * @brief Affiche certains éléments d'un sprite
 * @param sprite 
 */
void print_sprite (sprite_t *sprite);

/**
 * @brief Génération d'une valeur aléatoire entre a (inclus) et b (exclu)
 * @param a valeur minimal
 * @param b valeur maximal exclu
 * @return int 
 */
int aleatoire (int a, int b);

/**
 * @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 Initialise plusieurs sprites du même type
 * 
 * @param sprite Sprite à initialiser
 * @param nomSprite Caractère permettant d'identifier les instances du sprite sur la carte
 * @param largeur 
 * @param hauteur 
 * @param compt nombre de sprite dans le tableau
 * @param map Carte du jeu sous forme de tableau de caractères
 */
void build_sprites_tab (sprite_t *sprite, char nomSprite, int largeur, int hauteur, int* compt, char** map);

/**
 * @brief retourne le SDL_Rect d'un sprite
 * 
 * @param sprite 
 * @return SDL_Rect 
 */
SDL_Rect get_rect (sprite_t *sprite);


/**
 * @brief récupère la valeur de la cuisson
 * 
 * @param ingre 
 * @return int état de la cuisson
 */
int get_cuisson (sprite_t *ingre);

/**
 * @brief Modifie la valeur de la cuisson
 * 
 * @param ingre 
 * @param cuisson 
 */
void set_cuisson(sprite_t *ingre, int cuisson);

/**
 * @brief signale que l'ingrédient est posée
 * 
 * @param ingredient 
 */
void set_posee (sprite_t* ingredient);

/**
 * @brief Signale que l'ingrédient est portée
 * 
 * @param ingredient 
 */
void set_portable (sprite_t* ingredient);

/**
 * @brief Ajoute à la position du sprite les valeurs indiquées
 * 
 * @param sprite 
 * @param x_move valeur à ajouter sur l'axe des abscisses
 * @param y_move valeur à ajouter sur l'axe des ordonnées
 */
void modif_position (sprite_t *sprite, int x_move, int y_move);

/**
 * \brief Vérifie si deux sprites sont en collisions
 * \param spr1 Sprite
 * \param spr2 Sprite
 * \param SDL_bool 0 si faux, 1 si vrai
 */
SDL_bool has_collided (sprite_t* spr1, sprite_t* spr2);


/**
 * \brief Vérifie si deux sprites sont en collisions
 * \param spr_move Sprite capable de se déplacer
 * \param spr_fixed Sprite immobile
 */
void handle_collision (sprite_t* spr_move, sprite_t* spr_fixed);

/**
 * @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);

/**
 * @brief donne le score actuelle de la partie
 * 
 * @param stocks 
 * @return int 
 */
int get_score(stock_t* stocks);

/**
 * \brief Gère les collisions du jeu
 * \param world Données du monde
 */
void limites_internes (world_t* world);

/**
 * \brief la fonction permet de rendre visible un sprite
 * \param sprite Les données d'un sprite
 */
void set_visible (sprite_t *sprite);

/**
 * \brief la fonction permet de rendre invisible un sprite
 * \param sprite Les données d'un sprite
 */
void set_invisible (sprite_t *sprite);

/**
 * @brief Sprite visible ou non
 * 
 * @param sprite 
 * @return int : 1 = visible, 0 = false
 */
int est_visible (sprite_t *sprite);

/**
 * \brief La fonction initialise les données du monde du jeu
 * \param world les données du monde
 */
void init_data(world_t * world);

/**
 * \brief retourne la valeur de fin de jeu (si 0: jeu continue)
 * \param world les données du monde
 * \return la valeur de fin de jeu (si 0: jeu continue)
 */
int estFini(world_t *world);

/**
 * \brief Gère les évenements en fonctions des entrées du joueur
 * \param event données des évenements
 * \param world les données du monde
 */
void gestion_events(SDL_Event *event, world_t *world);

/**
 * @brief Génère la map de départ du jeu
 * 
 * @return tableau correspondant au contenu de base de la map
 */
char** init_map ();


/**
 * @brief Indique que le sprite face le bas
 * 
 * @param sprite 
 */
void set_bas (sprite_t *sprite);

/**
 * @brief Indique que le sprite face le haut
 * 
 * @param sprite 
 */
void set_haut (sprite_t *sprite);

/**
 * @brief Indique que le sprite face vers la droite
 * 
 * @param sprite 
 */
void set_droite (sprite_t *sprite);

/**
 * @brief Indique que le sprite face vers la gauche
 * 
 * @param sprite 
 */
void set_gauche (sprite_t *sprite);

/**
 * @brief Retourne l'état du sprite
 * 
 * @param sprite 
 * @return int valeur de l'état actuel du sprite
 */
int return_state (sprite_t *sprite);

/**
 * @brief gestions des limites des murs 
 * 
 * @param sprite sprite pour lequel on test les limites
 * @param world données du monde
 */
void limites_externes (sprite_t *sprite);

/**
 * @brief Retire le sprite de la map - avant maj d'un déplacement
 * 
 * @param sprite sprite
 * @param world données du monde
 */
void reset_sprite_on_map (sprite_t *sprite, world_t *world);


/**
 * @brief Place le sprite sur la map - avant maj d'un déplacement
 * 
 * @param sprite 
 * @param world 
 */
void place_sprite_on_map (sprite_t *sprite, world_t *world);

/**
 * @brief Mets à jour les données du monde en fonction des évolutions et des limites du jeu
 * 
 * @param world Données du monde
 */
void update_data (world_t *world);

#endif