void Unite::deplacer(int abd_arr,int ord_arr,Tuile *plateau[][NBH])
{
 
 int x,y;
 int limite=0;
 int arriver=0;
 
 ofstream fermee("ferme.txt",ios::out);
 ofstream ouvert("ouvert.txt",ios::out);
 ofstream cout("tuile.txt",ios::out);
 
 Tuile *depart,*arrive,*case_actuel;   
 vector <Tuile*> liste_ouverte,liste_ferme,case_adjacente;
 vector <Tuile*>::iterator it,it2,it3;
 
 x=(position.x)/16;
 y=(position.y)/16;
 
    while(abd_arr%16!=0)
        {
    abd_arr--;
    }
       
    while(ord_arr%16!=0)
    {
        ord_arr--;
    }
 
 //on defini les case depart /arrive       
 depart=plateau[x][y];
 arrive=plateau[abd_arr/16][ord_arr/16];
 
 //on calcule le cout H
      for(x=0;x<NBL;x++)
        {
            for(y=0;y<NBH;y++)
            {   
             
            plateau[x][y]->H=fabs((((((plateau[x][y]->position.x)-(arrive->position.x))/16)*10)+
            ((((plateau[x][y]->position.y)-(arrive->position.y))/16)*10)));

            }
        }
       
 liste_ouverte.push_back(depart);
 
 do
 {
       
 it=min_element(liste_ouverte.begin(),liste_ouverte.end(),::fct);     
 case_actuel=plateau[(*it)->position.x/16][(*it)->position.y/16];
 liste_ferme.push_back(plateau[(*it)->position.x/16][(*it)->position.y/16]);

 it=remove(liste_ouverte.begin(),liste_ouverte.end(),(*it));
 liste_ouverte.erase(liste_ouverte.begin(),it);
 
 case_adjacente.push_back(plateau[case_actuel->position.x/16-1][case_actuel->position.y/16-1]);
 case_adjacente.push_back(plateau[case_actuel->position.x/16][case_actuel->position.y/16-1]);
 case_adjacente.push_back(plateau[case_actuel->position.x/16+1][case_actuel->position.y/16-1]);
 case_adjacente.push_back(plateau[case_actuel->position.x/16-1][case_actuel->position.y/16]);
 case_adjacente.push_back(plateau[case_actuel->position.x/16+1][case_actuel->position.y/16]);
 case_adjacente.push_back(plateau[case_actuel->position.x/16-1][case_actuel->position.y/16+1]);
 case_adjacente.push_back(plateau[case_actuel->position.x/16][case_actuel->position.y/16+1]);
 case_adjacente.push_back(plateau[case_actuel->position.x/16+1][case_actuel->position.y/16+1]);

 for(it3=case_adjacente.begin();it3!=case_adjacente.end();it3++)
 {      
 
 //si la case est intraversable
        if
        (

                ((nom->Cmp("avions")==0||nom->Cmp("bombardier")==0||nom->Cmp("helico_combat")==0||
        nom->Cmp("helico_bombardier")==0)&& (*it3)->occupe!=1)||
                       
                ((nom->Cmp("fregate")==0||nom->Cmp("corvette")==0||nom->Cmp("croiseur")==0||
        nom->Cmp("sous_marin")==0)&&(*it3)->occupe!=2)||
               
                ((nom->Cmp("transporteur")==0||nom->Cmp("tank_medium")==0||nom->Cmp("tank")==0||
        nom->Cmp("rocket")==0||nom->Cmp("mech")==0||nom->Cmp("infantry")==0||
        nom->Cmp("lance_missile")==0||nom->Cmp("eclaireur")==0||nom->Cmp("constructeur")==0||
        nom->Cmp("canon")==0 )&& (*it3)->occupe!=0)
           
                )
        {
            //on ne fait rien
        }
               
                //si elle n'est pas dans liste_ouverte
                //if(search_n(liste_ouverte.begin(),liste_ouverte.end(),1,(*it3),::fct2)!=liste_ouverte.end())
        if(search_n(liste_ouverte.begin(),liste_ouverte.end(),1,(*it3))!=liste_ouverte.end())//la fonction de recherche plante
        {   
            if(liste_ouverte.capacity()!=0)
            {
            liste_ouverte.push_back(plateau[(*it3)->position.x/16][(*it3)->position.y/16]);
            (*it3)->parent=case_actuel;
            calculer_cout(plateau[(*it3)->position.x/16][(*it3)->position.y/16],case_actuel);
            }
        }
        //*
        else
                {
            vector <Tuile*>::iterator it;
            it=search_n(liste_ouverte.begin(),liste_ouverte.end(),1,(*it3));//cellle ci aussi
           
            //si elle est dans la liste ouvertes
            if((*it)==(*it3))
            {      
                                //si c'est un meilleur chemin
                    if(case_actuel->G>(*it)->G)
                    {
                       (*it)->parent=case_actuel;
                       calculer_cout(plateau[(*it)->position.x/16][(*it)->position.y/16],case_actuel);
                       stable_sort(liste_ouverte.begin(),liste_ouverte.end(),::fct);//mais pas la fonction de tri
                    }
                   
                                        //si c'est la case rechercher.
                    if((*it3)==arrive)
                    {
                    arriver=1;   
                    }
            }
        }
      case_adjacente.clear(); 
 //
 }
 limite++;
 if(limite>150){arriver=1;}
 }
 while (limite<150 || arriver==0);//|| liste_ouverte.size()!=0)
 
 
 
 wxMessageBox("OK chemin");

class Tuile
{
public:
   
//Tuile* operator <(Tuile * tuile);
Tuile *parent;
SDL_Rect position,*Position;     
SDL_Surface *terrain;
int decouvert,occupe;
char type;
double F,G,H;
int arrive;
Tuile(SDL_Rect position1,SDL_Surface *surface1,char c);
bool operator ==(Tuile *T);
   
};
//==============================================================================
class Unite
{
private:
const wxString *ID;
int attaque;
SDL_Rect position;
int cout;

public:
wxString *nom; 
void Unite::calculer_cout (Tuile *case_a_tester,Tuile *case_en_cour);
Unite(wxString ID1, wxString nom1,SDL_Rect *Position_depart,Camp *Jaune);
~Unite();

SDL_Rect get_position(void);

SDL_Rect *Position;
SDL_Surface *unite_actuel;
SDL_Surface *unite[2];
int vie;
int nb_mvt;
void deplacer(int abs,int ord);
void Unite::deplacer(int abd_arr,int ord_arr,Tuile *plateau[][NBH]);
};

void Unite::calculer_cout (Tuile *case_a_tester,Tuile *case_en_cour)
{
             
            if(case_en_cour->position.x!=case_a_tester->position.x && case_en_cour->position.y!=case_a_tester->position.y)
            {
                case_a_tester->G=(case_en_cour->G)+14;
            }
            else if (case_en_cour->position.x!=case_a_tester->position.x || case_en_cour->position.y!=case_a_tester->position.y)
            {
                 case_a_tester->G=(case_en_cour->G)+10;
            }
            case_a_tester->F=(case_a_tester->H)+(case_a_tester->G);
           
}


bool Tuile::operator ==(Tuile *T)
{
if(this->position.x==T->position.x && this->position.y==T->position.y)
return true;
else return false;   
}

bool fct(Tuile* T1,Tuile* T2)
{
    if((T1->F)<(T2->F))
    return true;
   
    else
    return false;   
}


bool fct2(const Tuile* T1,const Tuile* T2)
{
  if((T1->position.x==T2->position.x) && (T1->position.y==T2->position.y))
    return true;
   
    else
    return false;

// equivaut a
// return ((T1->position.x==T2->position.x) && (T1->position.y==T2->position.y));
}

ofstream cout("tuile.txt",ios::out);