deplacements.c

#include <stdio.h>
#include <stdlib.h>
#include "structures.h"
#include "case.h"
#include "personnage.h"
#include "deplacements.h"

/*!
* \file deplacements.c
* \brief Fichier contenant le code des fonctions liees aux déplacements des personnages.
*/

/*!
 * \fn boolean case_a_cote(Personnage * perso, Case * destination)
 * \brief La fonction vérifie que la case hexagonale "destination" est contigue à la case du personnage
 *
 * \param Un personnage, une case
 * \return Un booleen.
 */
boolean case_a_cote(Personnage * perso, Case * destination){
    Case *depart = getPosition(perso);
    int i;
    if (get_x(depart)>get_x(destination)+1||get_x(depart)<get_x(destination)-1||get_y(depart)>get_y(destination)+1||get_y(depart)<get_y(destination)-1){
        return faux;
    }
    for(i=0;i<LARG_MAX_CARTE;i+=2){
        if (get_y(depart)==get_y(destination)+1&&get_x(depart)!=get_x(destination)&&get_x(depart)==i+1)
            return faux;
        if (get_y(depart)==get_y(destination)-1&&get_x(depart)!=get_x(destination)&&get_x(depart)==i)
            return faux;
    }
    return vrai;
}

/*!
 * \fn deplacement_unitaire(Personnage *perso,Case * destination)
 * \brief déplace un personnage sur une case située à côté de la sienne, si cela est possible
 *
 * \param Un personnage, une case
 * \return 0 si le deplacement est possible et a ete effectue, 1 si il n'est pas possible ou n'a pas fonctionne
 */
int deplacement_unitaire(Personnage *perso,Case * destination){
    if (est_occupee(destination)==vrai){
        printf("deplacement impossible : case deja occupee par un personnage\n");
        return 1;
    }
    if (case_franchissable(destination)==faux){
        printf("deplacement impossible : case infranchissable\n");
        return 1;
    }
    if (perso->points_deplacement<destination->terrain->PD_requis){
        printf("pas assez de points de deplacements\n");
        return 1;
    }
    if (case_a_cote(perso,destination)==vrai){
       if(deplacer_personnage(perso, destination)==0){
            perso->points_deplacement-=destination->terrain->PD_requis;
            return 0;
       }
    }
    printf("deplacement impossible : case non contigue\n");
    return 1;
}

/*!
 * \fn boolean case_a_cote_case(Case * depart, Case * destination)
 * \brief verifie si deux cases sont cote-a-cote
 *
 * \param la case de depart, la case d'arrivee
 * \return vrai ou faux
 */
boolean case_a_cote_case(Case * depart, Case * destination){
    int i;
    if (get_x(depart)>get_x(destination)+1||get_x(depart)<get_x(destination)-1||get_y(depart)>get_y(destination)+1||get_y(depart)<get_y(destination)-1){
        return faux;
    }
    for(i=0;i<LARG_MAX_CARTE;i+=2){
        if (get_y(depart)==get_y(destination)+1&&get_x(depart)!=get_x(destination)&&get_x(depart)==i+1)
            return faux;
        if (get_y(depart)==get_y(destination)-1&&get_x(depart)!=get_x(destination)&&get_x(depart)==i)
            return faux;
    }
    return vrai;
}

/*!
 * \fn boolean deplacement_unitaire_possible(Case* depart,Case* destination)
 * \brief verifie si on peut de deplacer d'une cas e a une autre
 *
 * \param la case de depart, la case d'arrivee
 * \return vrai si le deplacement est possible, faux si il n'est pas possible
 */
boolean deplacement_unitaire_possible(Case* depart,Case* destination){
    if (est_occupee(destination)==vrai){
        return faux;
    }
    if (case_franchissable(destination)==faux){
        return faux;
    }
    if (case_a_cote_case(depart,destination)==vrai){
        return vrai;
       }
    return faux;
}

/*!
 * \fn boolean deplacement_possible(Personnage* perso, Case* c, Carte_Jeu* carte)
 * \brief verifie si un personnage peut se rendre sur une case distante en fonction de ses points de mouvement
 *
 * \param le personnage, la case d'arrivee, la carte
 * \return vrai si le deplacement est possible, faux si il n'est pas possible
 */
boolean deplacement_possible(Personnage* perso, Case* c, Carte_Jeu* carte){
    int pts_mvt = perso->points_deplacement;
    Case* depart=perso->position;
    if(depart->coord_x>c->coord_x+pts_mvt||depart->coord_x<c->coord_x-pts_mvt||depart->coord_y>c->coord_y+pts_mvt||depart->coord_y<c->coord_y-pts_mvt) return faux;
     if(pts_mvt<c->terrain->PD_requis) return faux;
    int x,y;
    for(x=depart->coord_x-pts_mvt;x<LARG_MAX_CARTE&&x<=depart->coord_x+pts_mvt;x++){
        for(y=depart->coord_y-pts_mvt;y<HAUT_MAX_CARTE&&y<=depart->coord_y+pts_mvt;y++){
            if(deplacement_unitaire_possible(depart,&carte->Tab_Cases[x][y])==vrai){
                if(deplacement_possible_recursif(&carte->Tab_Cases[x][y],c, carte,pts_mvt-carte->Tab_Cases[x][y].terrain->PD_requis)==vrai){
                    return vrai;
                }
            }
        }
    }
    return faux;
}

/*!
 * \fn boolean deplacement_possible_recursif(Case* dep, Case* dest, Carte_Jeu* carte, int pts_restants)
 * \brief fonction recursive appellee par deplacement_possible, elle a le meme role
 *
 * \param une case depart, une case arrivee, la carte, les points de mouvement du personnage
 * \return vrai si le deplacement est possible, faux si il n'est pas possible
 */
boolean deplacement_possible_recursif(Case* dep, Case* dest, Carte_Jeu* carte, int pts_restants){
    int x,y;
    if(dep==dest) return vrai;
    if(pts_restants<dest->terrain->PD_requis) return faux;
    for(x=dep->coord_x-pts_restants;x<LARG_MAX_CARTE&&x<=dep->coord_x+pts_restants;x++){
        for(y=dep->coord_y-pts_restants;y<HAUT_MAX_CARTE&&y<=dep->coord_y+pts_restants;y++){
                if(deplacement_unitaire_possible(dep,&carte->Tab_Cases[x][y])==vrai){
                    if(deplacement_possible_recursif(&carte->Tab_Cases[x][y],dest, carte,pts_restants-carte->Tab_Cases[x][y].terrain->PD_requis)==vrai){
                        return vrai;
                    }
                }
            }
    }
    return faux;
}