case.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "terrain.h"
#include "structures.h"
#include "personnage.h"
#include "deplacements.h"
#include "partie.h"

/*!
* \file case.c
* \brief Fichier contenant le code des fonctions liees aux cases
*/

void init_case(Case * c,int x,int y, Terrain *t){
    c->coord_x=x;
    c->coord_y=y;
    c->terrain=t;
    c->occupee=faux;
}

int get_x(Case *c){
    return c->coord_x;
}

int get_y(Case *c){
    return c->coord_y;
}

  /*!
 * \fn char * getID(Carte_Jeu * c)
 * \brief La fonction retourne un pointeur vers l'ID de la Carte_Jeu.
 *
 * \param Un pointeur vers la Carte_Jeu à tester
 * \return Le pointeur vers l'ID de la Carte_Jeu.
 */
char * getID(Carte_Jeu * c){
    return c->id;
}

  /*!
 * \fn Case * getCase(Carte_Jeu * c, int x, int y)
 * \brief La fonction retourne un pointeur vers la Case de la Carte_Jeu aux coordonnées x,y.
 *
 * \param Un pointeur vers la Carte_Jeu à tester et les coordonnées x et y en entier.
 * \return un pointeur vers la Case aux coordonnées x, y.
 */
Case * getCase(Carte_Jeu * c, int x, int y){
    return &c->Tab_Cases[x][y];
}

boolean est_occupee(Case *c){
    return c->occupee;
}

boolean case_franchissable(Case *c){
    return terrain_franchissable(c->terrain);
}

void marquer_occupee(Case *c){
    c->occupee=vrai;
}

void marquer_libre(Case *c){
    c->occupee=faux;
}

Terrain* get_terrain(Case *c){
    if (c->terrain==NULL){
        return NULL;
    }
    return c->terrain;
}

  /*!
 * \fn Carte_Jeu * nouvelleCarte()
 * \brief La fonction alloue l'espace en memoire pour une structure Carte_Jeu et renvoye un pointeur vers la structure creee
 *
 * \return Le pointeur vers la Carte_Jeu creee.
 */
Carte_Jeu * nouvelleCarte(){
    Carte_Jeu * c = malloc(sizeof(Carte_Jeu));
    return c;
}

  /*!
 * \fn void deleteCarte(Carte_Jeu * c)
 * \brief libere l'espace memoire alloue a une Carte_Jeu
 *
 * \param le pointeur vers la Carte_Jeu a supprimer.
 */
void deleteCarte(Carte_Jeu * c){
    free(c);
}

  /*!
 * \fn int initCarte(Carte_A * sourceXML, Carte_Jeu * destination, Terrain * terrainPackage)
 * \brief La fonction initialise la Carte_Jeu a partir de la Carte_A du Package passée en parametre.
 *
 * \param Un pointeur vers la Carte_A du package qui sera la source, un pointeur vers la Carte_Jeu a initialiser, un pointeur vers le Game_Package de l'univers du jeu
 * \return 1 si l'initialisation est correcte, 0 sinon.
 */
int initCarte(Carte_A * sourceXML, Carte_Jeu * destination, Game_Package * pack){
    int i,j;
    strncpy(getID(destination), sourceXML->id, TAILLE_ID);
    for(i=0;i<LARG_MAX_CARTE;i++){
        for(j=0;j<HAUT_MAX_CARTE;j++){
            switch (sourceXML->lignes[i][j]){
                case 'P' :
                    init_case(getCase(destination,i,j),i,j,&pack->Terrains_Package[0]);
                    break;
                case 'R' :
                    init_case(getCase(destination,i,j),i,j,&pack->Terrains_Package[1]);
                    break;
                case 'F' :
                    init_case(getCase(destination,i,j),i,j,&pack->Terrains_Package[2]);
                    break;
                case 'M' :
                    init_case(getCase(destination,i,j),i,j,&pack->Terrains_Package[3]);
                    break;
                default :
                    return 0;
            }
        }
    }
    return 1;
}

  /*!
 * \fn int adjacente(Case * depart, Case * cible)
 * \brief La fonction teste si la case cible est adjacente à la case départ.
 *
 * \param un pointeur vers la case de départ, un pointeur vers la case à tester
 * \return 1 si la case est adjacente, 0 sinon.
 */
int adjacente(Case * depart, Case * cible){
    if(get_x(cible)==get_x(depart)){
        if((get_y(cible)==get_y(depart)-1)||(get_y(cible)==get_y(depart)+1)){
            return 1;
        }
        else{
            return 0;
        }
    }
    else if((get_x(cible)==(get_x(depart)-1))||(get_x(cible)==(get_x(depart)+1))){
        if(get_x(depart)%2==1){
            if((get_y(cible)==get_y(depart))||(get_y(cible)==get_y(depart)-1)){
                return 1;
            }
            else{
                return 0;
            }
        }
        else{
            if((get_y(cible)==get_y(depart))||(get_y(cible)==get_y(depart)+1)){
                return 1;
            }
            else{
                return 0;
            }
        }
    }
    else{
        return 0;
    }
}

  /*!
 * \fn APorteeRecursif(Carte_Jeu * c, Case * depart, Case * cible,int portee)
 * \brief La fonction teste si la case cible est a portée de la case de départ.
 *
 * \param La carte sur laquelle on fait le test, un pointeur vers la case de départ, un pointeur vers la case à tester, un entier representant la portée
 * \return 1 si la case est à portée, 0 sinon.
 */
int APorteeRecursif(Carte_Jeu * c, Case * depart, Case * cible,int portee){
    int i,j;

    if(depart==cible){
        return (cible->terrain->franchissable_sorts==vrai);
    }

    else if((portee==1)&&(adjacente(depart,cible))){
        return (cible->terrain->franchissable_sorts==vrai);
    }
    else{
        portee--;
        for((i=get_x(depart)-portee);((i<LARG_MAX_CARTE)&&(i<=get_x(depart)+portee));i++){
            for((j=get_y(depart)-portee);((j<HAUT_MAX_CARTE)&&(j<=get_y(depart)+portee));j++){
                if(adjacente(getCase(c,i,j),depart)){
                    if(APorteeRecursif(c,getCase(c,i,j),cible,portee)){
                        return (cible->terrain->franchissable_sorts==vrai);
                    }
                }
            }
        }
    return 0;
    }
}