//Function récursive
struct Noeud* chercher(Arbre* racine, int valeur)
{
//Dans le cas ou la racine est null ou la valeur est trouvée
if(racine == NULL || valeur == racine->valeur)
{
if(racine == NULL)
{
//Retourn null
racine = NULL;
}
else
{
//On retourne la racine
racine = racine;
}
}
//Dans le cas ou nous n'avons pas encore trouvée la valeur on regarde dans les sous arbre
else
{
//On regarde à gauche si valeur inférieur
if(valeur < racine->valeur)
{
racine = chercher(racine->gauche,valeur);
}
//On regarde à droite dans le cas contraire
else
{
racine = chercher(racine->droit,valeur);
}
}
return racine;
}
// OK
// Probleme avec le return temp ajoute un '%' à la fin.
// Ce n'est pas un problème d'affichage.
// Si l'on fait un simple return arbre2 dans la fonction on se retrouve aussi avec ce '%'. Problème non corrigé.
Arbre* fusion(Arbre* arbre1, Arbre* arbre2)
{
Arbre * temp = arbre2;
if(arbre2 != NULL && arbre1 != NULL)
{
// On recherche pour voir si la valeur arbre 1 est dans l'arbre 2
if (chercher(arbre2,arbre1->valeur) == NULL)
{
// Dans le cas non on l'insère
inserer(arbre2, arbre1->valeur);
}
// On fait de même pour l'arbre gauche et droite
arbre2 = fusion(arbre1->gauche, arbre2);
arbre2 = fusion(arbre1->droit, arbre2);
temp = arbre2;
}
else
{
if (arbre2 == NULL )
{
temp = arbre1;
}
else if (arbre1 == NULL)
{
temp = arbre2;
}
}
return temp;
}
//OK
struct Noeud* successeur(Arbre* racine, int valeur)
{
struct Noeud* temp;
int trouve=0;
temp = chercher(racine,valeur);
//Si la valeur est bien présente dans l'arbre
if(temp != NULL)
{
//Dans le cas ou il n'y a pas de sous arbre droit
if(minimum(temp->droit) == NULL)
{
//Successeur dans ses parents
temp = parent(racine,valeur);
while(temp != NULL && trouve==0)
{
if(temp->valeur < valeur)
{
temp = parent(racine,temp->valeur);
}
else trouve =1;
}
}
else
{
//On prend le plus petits des sous arbre droit
temp = minimum(temp->droit);
}
}
return temp;
}
//OK
struct Noeud* predecesseur(Arbre* racine, int valeur)
{
struct Noeud* temp;
int trouve=0;
temp = chercher(racine,valeur);
//Si la valeur est bien présente dans l'arbre
if(temp != NULL)
{
//Dans le cas ou il n'y a pas de sous arbre gauche
if(minimum(temp->gauche) == NULL)
{
//Predecesseur dans ses parents
temp = parent(racine,valeur);
while(temp != NULL && trouve==0)
{
if(temp->valeur > valeur)
{
temp = parent(racine,temp->valeur);
}
else trouve =1;
}
}
else
{
//On prend le plus grand des sous arbre gauche
temp = maximum(temp->gauche);
}
}
return temp;
}
////////////////////////////////////////////////////////////////////////
///
/// @fn NoeudAbstrait* ArbreRendu::ajouterNouveauNoeud(const std::string& typeParent, const std::string& typeNouveauNoeud)
///
/// Cette fonction permet d'ajouter un nouveau noeud dans l'arbre de
/// rendu.
///
/// @param[in] typeParent : Le type du parent du nouveau noeud.
/// @param[in] typeNouveauNoeud : Le type du nouveau noeud.
///
/// @return Le noeud nouvellement créé.
///
////////////////////////////////////////////////////////////////////////
NoeudAbstrait* ArbreRendu::ajouterNouveauNoeud(
const std::string& typeParent,
const std::string& typeNouveauNoeud
)
{
NoeudAbstrait* parent = chercher(typeParent);
if (parent == 0) {
// Incapable de trouver le parent
return 0;
}
NoeudAbstrait* nouveauNoeud = creerNoeud(typeNouveauNoeud);
if (nouveauNoeud)
parent->ajouter(nouveauNoeud);
return nouveauNoeud;
}
int Chemin(SDL_Rect PositionOrig,SDL_Rect PositionDest)
{
noeud ferme[Nb_Bloc_Largeur*Nb_Bloc_Hauteur]={};//la liste qui contient le chemin
noeud ouvert[Nb_Bloc_Largeur*Nb_Bloc_Hauteur]={};//tout les noeud possible a parcourir
int l=0;
for(l=0 ; l<Nb_Bloc_Largeur*Nb_Bloc_Hauteur ; l++) tri9[l].i=tri9[l].j=-1;
int videO,videF;// tester est ce que l ensemble ouvert et vide ou non
videO=videF=0;//les ensembles sont vides au debut
noeud considere;//le noeud qui subit les iterations
noeud successeur;//pour inserer les voisins
int x,y;//pour les coords des noeuds
int dO,dF;//dans la liste ouverte et dans la liste fermée
int succe=0;//un boulien qui declare l existence ou nn du chemin
ouvert[0].coup=0;
ouvert[0].estimation=distance((PositionOrig.x - cte1)/Taille_Bloc,(PositionOrig.y - cte2)/Taille_Bloc,(PositionDest.x - cte1)/Taille_Bloc,(PositionDest.y - cte2)/Taille_Bloc);
ouvert[0].evaluation=ouvert[0].estimation + ouvert[0].coup;
ouvert[0].coords.i=ouvert[0].parent.i=(PositionOrig.x - cte1)/Taille_Bloc;
ouvert[0].coords.j=ouvert[0].parent.j=(PositionOrig.y - cte2)/Taille_Bloc;
videO++;
while(videO != 0 && succe==0)//debut de la recherche du chemin
{
considere=lemeilleur(ouvert,videO);//on choisit le noeud consideré de telle sorte qu'il soit de poids minim
if(considere.coords.i==((PositionDest.x - cte1)/Taille_Bloc) && considere.coords.j==((PositionDest.y - cte2)/Taille_Bloc))
succe=1;//c'est fini
else {
supprimernoeud(considere,ouvert,videO);//sinon on le retire de la liste ouverte
videO--;
ajouterliste(considere,ferme,videF);//on l insert dans la liste fermée puisqu il est de poids minimal
videF++;
//on ajoute mnt tous les noeuds adjacents
x=considere.coords.i+1;// les coords du noeud d adroite
y=considere.coords.j;
if(grille[x][y]==EMPTY && considere.coords.i<Nb_Bloc_Hauteur-1)//le noeud d'adroite doit etre vide et ne doit pas etre hors la grille
{ dO=dansliste(x,y,ouvert,videO); dF=dansliste(x,y,ferme,videF);
if(dO==0 && dF==0)
//si le noeud n'est ni dans la liste fermée ni ouverte
{
successeur.coup=considere.coup + 1;
successeur.estimation=distance(x,y,(PositionDest.x - cte1)/Taille_Bloc,(PositionDest.y - cte2)/Taille_Bloc);
successeur.evaluation=successeur.estimation+successeur.coup;
successeur.coords.i=x;//les coords de successeur
successeur.coords.j=y;
successeur.parent=considere.coords;//celles de son parent seront du noeud consideré en ce moment
ajouterliste(successeur,ouvert,videO);//on l ajoute a la liste ouverte pour choisir dans la prochaine iteration le meilleur noeud
videO++;
}
else {
if(dO==1) successeur=chercher(x,y,ouvert); else successeur=chercher(x,y,ferme);
if(successeur.evaluation>(distance(x,y,(PositionDest.x - cte1)/Taille_Bloc,(PositionDest.y - cte2)/Taille_Bloc)+considere.coup+1))
{
successeur.parent=considere.coords;
successeur.coup=considere.coup + 1;
successeur.estimation=distance(x,y,(PositionDest.x - cte1)/Taille_Bloc,(PositionDest.y - cte2)/Taille_Bloc);
successeur.evaluation=successeur.estimation+successeur.coup;
if(dF==1)
{
supprimernoeud(successeur,ferme,videF);
videF--;
ajouterliste(successeur,ouvert,videO);
videO++;
}
else
{
supprimernoeud(successeur,ouvert,videO);
videO--;
ajouterliste(successeur,ouvert,videO);
videO++;
}
}
}
}
x=considere.coords.i-1;// les coords du noeud d agauche
y=considere.coords.j ;
if(grille[x][y]==EMPTY && considere.coords.i>0)//le noeud d'agauche doit etre vide et ne doit pas etre hors la grille
{ dO=dansliste(x,y,ouvert,videO); dF=dansliste(x,y,ferme,videF);
if(dO==0 && dF==0)
//si le noeud n'est ni dans la liste fermée ni ouverte
{
successeur.coup=considere.coup + 1;
successeur.estimation=distance(x,y,(PositionDest.x - cte1)/Taille_Bloc,(PositionDest.y - cte2)/Taille_Bloc);
successeur.evaluation=successeur.estimation+successeur.coup;
//calcule du cout par la fct distance
successeur.coords.i=x;//les coords de successeur
successeur.coords.j=y;
successeur.parent=considere.coords;//celles de son parent seront du noeud consideré en ce moment
ajouterliste(successeur,ouvert,videO);//on l ajoute a la liste ouverte pour choisir dans la prochaine iteration le meilleur noeud
videO++;
}
else {
if(dO==1) successeur=chercher(x,y,ouvert); else successeur=chercher(x,y,ferme);
if(successeur.evaluation>(distance(x,y,(PositionDest.x - cte1)/Taille_Bloc,(PositionDest.y - cte2)/Taille_Bloc)+considere.coup+1))
{
successeur.parent=considere.coords;
successeur.coup=considere.coup + 1;
successeur.estimation=distance(x,y,(PositionDest.x - cte1)/Taille_Bloc,(PositionDest.y - cte2)/Taille_Bloc);
successeur.evaluation=successeur.estimation+successeur.coup;
if(dF==1)
{
supprimernoeud(successeur,ferme,videF);
videF--;
ajouterliste(successeur,ouvert,videO);
videO++;
}
else
{
supprimernoeud(successeur,ouvert,videO);
videO--;
ajouterliste(successeur,ouvert,videO);
videO++;
}
}
}
}
x=considere.coords.i;// les coords du noeud d bas
y=considere.coords.j+1;
if(grille[x][y]==EMPTY && considere.coords.j<Nb_Bloc_Largeur-1)//le noeud d'adroite doit etre vide et ne doit pas etre hors la grille
{ dO=dansliste(x,y,ouvert,videO); dF=dansliste(x,y,ferme,videF);
if(dO==0 && dF==0)
//si le noeud n'est ni dans la liste fermée ni ouverte
{
successeur.coup=considere.coup + 1;
successeur.estimation=distance(x,y,(PositionDest.x - cte1)/Taille_Bloc,(PositionDest.y - cte2)/Taille_Bloc);
successeur.evaluation=successeur.estimation+successeur.coup;
successeur.coords.i=x;//les coords de successeur
successeur.coords.j=y;
successeur.parent=considere.coords;//celles de son parent seront du noeud consideré en ce moment
ajouterliste(successeur,ouvert,videO);//on l ajoute a la liste ouverte pour choisir dans la prochaine iteration le meilleur noeud
videO++;
}
else {
if(dO==1) successeur=chercher(x,y,ouvert); else successeur=chercher(x,y,ferme);
if(successeur.evaluation>(distance(x,y,(PositionDest.x - cte1)/Taille_Bloc,(PositionDest.y - cte2)/Taille_Bloc)+considere.coup+1))
{
successeur.parent=considere.coords;
successeur.coup=considere.coup + 1;
successeur.estimation=distance(x,y,(PositionDest.x - cte1)/Taille_Bloc,(PositionDest.y - cte2)/Taille_Bloc);
successeur.evaluation=successeur.estimation+successeur.coup;
if(dF==1)
{
supprimernoeud(successeur,ferme,videF);
videF--;
ajouterliste(successeur,ouvert,videO);
videO++;
}
else
{
supprimernoeud(successeur,ouvert,videO);
videO--;
ajouterliste(successeur,ouvert,videO);
videO++;
}
}
}
}
x=considere.coords.i;// les coords du noeud d haut
y=considere.coords.j-1 ;
if(grille[x][y]==EMPTY && considere.coords.j>0)//le noeud d'agauche doit etre vide et ne doit pas etre hors la grille
{ dO=dansliste(x,y,ouvert,videO); dF=dansliste(x,y,ferme,videF);
if(dO==0 && dF==0)
//si le noeud n'est ni dans la liste fermée ni ouverte
{
successeur.coup=considere.coup + 1;
successeur.estimation=distance(x,y,(PositionDest.x - cte1)/Taille_Bloc,(PositionDest.y - cte2)/Taille_Bloc);
successeur.evaluation=successeur.estimation+successeur.coup;
//calcule du cout par la fct distance
successeur.coords.i=x;//les coords de successeur
successeur.coords.j=y;
successeur.parent=considere.coords;//celles de son parent seront du noeud consideré en ce moment
ajouterliste(successeur,ouvert,videO);//on l ajoute a la liste ouverte pour choisir dans la prochaine iteration le meilleur noeud
videO++;
}
else {
if(dO==1) successeur=chercher(x,y,ouvert); else successeur=chercher(x,y,ferme);
if(successeur.evaluation>(distance(x,y,(PositionDest.x - cte1)/Taille_Bloc,(PositionDest.y - cte2)/Taille_Bloc)+considere.coup+1))
{
successeur.parent=considere.coords;
successeur.coup=considere.coup + 1;
successeur.estimation=distance(x,y,(PositionDest.x - cte1)/Taille_Bloc,(PositionDest.y - cte2)/Taille_Bloc);
successeur.evaluation=successeur.estimation+successeur.coup;
if(dF==1)
{
supprimernoeud(successeur,ferme,videF);
videF--;
ajouterliste(successeur,ouvert,videO);
videO++;
}
else
{
supprimernoeud(successeur,ouvert,videO);
videO--;
ajouterliste(successeur,ouvert,videO);
videO++;
}
}
}
}
}
}
while(videF!=0)
{
videF--;
}
while(videO!=0)
{
videO--;
}
if(succe == 1)
{
reconstituer(considere,ferme,PositionOrig);
return 1;
}
else return 0;
}
