/Expertbot/regles/regles.cpp

#include <vector>
#include <iostream>
#include <cstdlib>
#include <string>
#include <math.h>
#include <fstream>
#include "../all2.h"
#include "../dico/Dico2.h"
#include "../Groupe.h"
#include "../traceur.h"

#include "predicat.cpp" //l'implémentation des fonctions utiles aux regles


regles::regles(Goban * gb, Ia* mon_Ia, traceur * tr) {
    g=gb;
    monIa = mon_Ia;
    Poids.resize(gb->getTaille());
    for (int i=0;(int)i<(int)Poids.size();i++) {
        Poids[i].resize(gb->getTaille());
    }
    fichier = new ofstream ("traceRegles.txt", ios::out | ios::trunc);  //déclaration du flux et ouverture du fichier
    fTrace = new ofstream ("traceReglesNG.txt", ios::out | ios::trunc);  //déclaration du flux et ouverture du fichier

    //traceTemp.clear();
    t = tr;
}




void regles::initFait() { //vector<int> faitsInit
    if(fichier){
        fichier->close();
    }
    //delete fichier;

    fichier = new ofstream (t->nomComplet("ReglesTxt").c_str(), ios::out | ios::trunc);
    fTrace = new ofstream (t->nomComplet("ReglesA").c_str(), ios::out | ios::trunc);

    #include "faitsDeBase.cpp"

}

void regles::reinittable(vector<vector<int> > * table) {
    for (int i=0; i<(int)table->size(); i++)
        for (int j=0; j<(int)(*table)[0].size(); j++)
            (* table)[i][j]=0;
}

vector<vector <int> > * regles::getZone(int numZone) {
//    cout<<"getcoin : "<<coin<<" - ";
    switch (numZone) {
    case COINSUPDROIT:
//            cout<<(* g->getcoinSupDroit())[0].size()<< " - "<<(* g->getcoinSupDroit())[1].size()<<endl;
        return g->getcoinSupDroit();
        break;

    case COININFDROIT:
//            cout<<(* g->getcoinInfDroit())[0].size()<< " - "<<(* g->getcoinInfDroit())[1].size()<<endl;
        return g->getcoinInfDroit();
        break;

    case COININFGAUCHE:
//            cout<<(* g->getcoinInfGauche())[0].size()<< " - "<<(* g->getcoinInfGauche())[1].size()<<endl;
        return g->getcoinInfGauche();
        break;

    case COINSUPGAUCHE:
//            cout<<(* g->getcoinSupGauche())[0].size()<< " - "<<(* g->getcoinSupGauche())[1].size()<<endl;
        return g->getcoinSupGauche();
        break;

    case BORDDROIT :
        return g->getbordDroit();
        break;

    case BORDGAUCHE :
        return g->getbordGauche();
        break;

    case BORDSUP :
        return g->getbordSup();
        break;

    case BORDINF :
        return g->getbordInf();
        break;

    case CENTRE :
        return g->getCentre();
        break;

    default :
        return 0;
        break;
    }
}

vector<vector <int> > * regles::getcoinJoseki(int coin) {

    switch (coin) {
    case COININFDROIT:
        return g->getcoinJosekiInfDroit();
        break;

    case COINSUPDROIT:
        return g->getcoinJosekiSupDroit();
        break;

    case COININFGAUCHE:
        return g->getcoinJosekiInfGauche();
        break;

    case COINSUPGAUCHE:
        return g->getcoinJosekiSupGauche();
        break;

    default:
        cout<<"regles::getcoinJoseki(int coin) : "<<coin<<" n'est pas un parametre valide pour coin"<<endl;
        return NULL;
        break;
    }
}

Goban * regles::getGoban() {

    return g;
}

Groupe * regles::getGroupe(int numgrp) {
    if (numgrp < GROUPE_BLANC) // groupe noir
        return (*(g->getListeGroupeN()))[numgrp-GROUPE_NOIR];
    else // groupe blanc
        return (*(g->getListeGroupeN()))[numgrp-GROUPE_BLANC];
}

Ia * regles::getIa() {
    return monIa;
}

vector<vector<int> > * regles::getPoids() { // retourne un pointeur sur poids
    return &Poids;
}

int regles::abscisse(int numInter) {
    return floor(numInter / g->getTaille() );
}

int regles::ordonnee(int numInter) {
    return numInter % g->getTaille();
}

char regles::couleurOppose(char couleur) {
    if (couleur == NOIR)
        return BLANC;
    else
        return NOIR;
}

char regles::getCouleur(int grp) {
    return (grp<GROUPE_BLANC) ? NOIR : BLANC;
}

Intersection * regles::centreZone(int z) {
    int abscisse, ordonnee, tailleGoban = g->getTaille();

    if (z == COININFGAUCHE || z == BORDGAUCHE || z == COINSUPGAUCHE)
        abscisse = 3;
    else if (z == BORDINF || z == BORDSUP)
        abscisse = (tailleGoban-1)/2;
    else
        abscisse = tailleGoban-4;

    if (z == COININFGAUCHE || z == BORDINF || z == COININFDROIT)
        ordonnee = 3;
    else if (z == BORDGAUCHE || z == BORDDROIT)
        ordonnee = (tailleGoban-1)/2;
    else
        ordonnee = tailleGoban-4;

    return g->getIntersection(abscisse, ordonnee);
}

Intersection * regles::getIntersection(int numInter) {
    return g->getIntersection(abscisse(numInter), ordonnee(numInter));
}

void regles::trace(int i, int j) {
    //cout<<"On est dans la trace numéro "<<t<<endl;
    *fichier<<"("<<i*g->getTaille()+j<<")";
    //return true;
}

void regles::trace(string s) {
    //cout<<"On est dans la trace numéro "<<t<<endl;
    *fichier<<s;
    //return true;
}

int regles::inter(int abscisse, int ordonnee) {
    return abscisse*g->getTaille() + ordonnee;
}



bool regles::alternerNoirBlanc(vector<vector <int> > * liste_coups, vector<vector <int> > * liste_ordonnee) {
    bool pierreTrouve = true;
    char tour = NOIR;
    for(int i =0; i < (int) (*liste_coups)[0].size() && pierreTrouve==true; i++){
        if(g->getPierre((*liste_coups)[i][0],(*liste_coups)[i][1])->couleur()==tour){
            tour = couleurOppose(tour);
        } else if (g->getPierre((*liste_coups)[i][0],(*liste_coups)[i][1])->couleur()==couleurOppose(tour)) {
            (*liste_ordonnee)[0].push_back(-1);
            (*liste_ordonnee)[1].push_back(-1);
        } else { // il n'y a pas de pierres
            pierreTrouve= false;
        }
        (*liste_ordonnee)[0].push_back((*liste_coups)[i][0]);
        (*liste_ordonnee)[1].push_back((*liste_coups)[i][1]);
    }
    return pierreTrouve;
}



int regles::numInterTengen() {
    return (g->getTaille() * g->getTaille() - 1) / 2;
}

int regles::abscisseTengen() {
    return (g->getTaille() - 1) / 2;
}

int regles::nbPierresGroupe(Groupe* grp) {
    return grp->getListe()->size();
}

void afficherVecteurInt(vector<int> * liste) { // affiche les données d'un vecteur d'entier, sert pour tester
    for (int i=0; i<(int)liste->size(); i++)
        cout<<(*liste)[i]<<" - ";
    cout<<endl;
}

void regles::ajouterFait(int fait) {
    machiaFait mf;
    mf.id = fait;
    mf.args.resize(0);
    ajouterFait(mf);
}


void regles::ajouterFait(machiaFait fait) {
    if (!testerFait(fait)) {//test si on ne l'a pas déja ajouté
        faits.push_back(fait);
    }
}


void regles::retirerFait(machiaFait fait) {
    bool argEgaux= false;
    int i=0;
    while (i<(int)faits.size()&&!argEgaux) {
        if (fait.id==faits[i].id) {
            int j =0;
            //tant qu'on est pas ŕ la fin des arguments et que les arguments sont égaux
            while (j<(int)faits[i].args.size() && faits[i].args[j]==fait.args[j]) {
                j++;
            }
            if (j==(int)faits[i].args.size()) {
                argEgaux=true;
            }
        }
        i++;
    }
    if (argEgaux) {
        faits.erase(faits.begin()+i);
    } else {
        cout<<"tentative de suppression d'un fait qui n'existe pas."<<endl;
    }
}

bool regles::testerFait(machiaFait fait) {

    bool argEgaux= false;
    int i=0;
    while (i<(int)faits.size() && !argEgaux) {
        if (fait.id==faits[i].id) {
            int j =0;
            //tant qu'on est pas ŕ la fin des arguments et que les arguments sont égaux
            while (j<(int)faits[i].args.size() && faits[i].args[j]==fait.args[j]) {
                j++;
            }
            if (j==(int)faits[i].args.size()) {
                argEgaux=true;
            }
        }
        i++;
    }
    return argEgaux;
}

bool regles::initNon(vector<int>  x, vector<int>  y) {

    traceNon.clear();

    for (int i=0;i<(int)x.size(); i++)
        traceNon.push_back(x[i]);

    traceNon2.clear();

    for (int i=0;i<(int)y.size(); i++)
        traceNon2.push_back(y[i]);

    return 1;
}

bool regles::initNon() {
    return 1;
}

bool regles::initNon(vector<int>  x) {
    traceNon.clear();
    for (int i=0;i<(int)x.size(); i++)
        traceNon.push_back(x[i]);
    return 1;
}


bool regles::inverser() {
    return 1;
}

//inversion d'arguments
bool regles::inverser(vector<int> * x, vector<int> * y) {

    inverser(x);
    traceNon.clear();

    for (int i=0;i<(int)traceNon2.size(); i++)
        traceNon.push_back(traceNon2[i]);

    inverser(y);
    return x->size()>0 && y->size()>0;
}

bool regles::inverser(vector<int> * x) {

    if ((int)(*x).size()>0) {
        vector<int> temp;
        /*
        //test si c'est des coins:
        if ((*x)[0] >=400 && (*x)[0] <=403)
                {
                    // temp.clear();
        */

        for (int i = 0; i < (int)traceNon.size(); i++) { //on met tous les coins SAUVEGARDES lors de la fonction appellée par le non, pour ne faire l'inversion que sur les éligibles
            temp.push_back(traceNon[i]);
        }

        for (int i=0; i<(int)(*x).size(); i++) { //on parcourt tous les coins qu'on veut inverser
            for (int j =0; j<(int)temp.size(); j++) {
                if (temp[j]==(*x)[i]) {
                    temp.erase(temp.begin()+j);    //on le vire si on le trouve
                }
            }
        }

        (*x).clear();
        for (int i=0; i<(int)temp.size(); i++) {
            (*x).push_back(temp[i]);
        }


        //si c'est des bords
        /*
        else if ((*x)[0] >=404 && (*x)[0] <=407)
                    {
                       //  temp.clear();
                        temp.push_back(404);temp.push_back(405);temp.push_back(406);temp.push_back(407); //on met tous les bords
                        for (int i=0; i<(*x).size(); i++){ //on parcourt tous les bords qu'on veut inverser
                                for (int j =0; j<temp.size(); j++){
                                    if (temp[j]==(*x)[i]) {temp.erase(temp.begin()+j);} //on le vire si on le trouve
                                    }
                            }

                            (*x).clear();
                            for (int i=0; i<temp.size(); i++){
                             (*x).push_back(temp[i]);
                            }

                        }*/

    }
    return x->size()>0;
}


//test fait sans argument
bool regles::testerFait(int nom) {

    machiaFait fait;
    fait.id=nom;
    int i=0;
    while (i<(int)faits.size()) {
        if (fait.id==faits[i].id) {
            return true;
        }
        i++;
    }
    return false;
}


//prend un argument
bool regles::testerFait(int nom, vector<int> * arg/*, ...*/) {

    machiaFait fait;
    fait.id=nom;

    //va_list ap;

    //va_start(ap, nom);

    if (arg!=NULL) {
        for (int i=0; i<(int)(*arg).size(); i++) {
            fait.args.push_back((*arg)[i]);
        }
    }
    /*
     vector<int> * parametre = va_arg(ap, vector<int> *);

    	while(parametre != NULL){ // ...Tant qu'on ne trouve pas le paramčtre NULL

    		{for (int i=0; i<(*parametre).size(); i++){
        fait.args.push_back((*parametre)[i]);}}

    		 vector<int> * parametre = va_arg(ap, vector<int> *);  // on obtient le paramčtre actuel

    	}

    	va_end(ap);
    */
    bool argEgaux= false;
    int i=0;
    while (i<(int)faits.size()&&!argEgaux) {
        if (fait.id==faits[i].id) {
            int j =0;
            //tant qu'on est pas ŕ la fin des arguments et que les arguments sont égaux
            // IL FAUDRAIT TESTER QUE TOUS LES ELEMENTS DU VECTEUR CONTENU DANS UN ARGUMENT SONT EGAUX !!!!!!!!!!!!
            while (j<(int)faits[i].args.size() && faits[i].args[j]==fait.args[j]) {
                j++;
            }
            if (j==(int)faits[i].args.size()) {
                argEgaux=true;
            }


        }
        i++;
    }

    return argEgaux;

}

bool regles::ajoutLib(vector<int> * numinter,vector <int> * numgrp, int nblib) { // retire de inter les intersections n'ajoutant pas au moins nblib libertés ŕ un groupe. Tous les groupes doivent ętre de la męme couleur
    int i=0, j, k, l, indiceGrps, abscisseInter, ordonneeInter, abscisseAdj, ordonneeAdj, nbLibertesBonus;
    char coul;
    bool grpTrouve;
    vector<Groupe*> grps;
    Groupe * grpActuel;

    if ((*numgrp)[0]<GROUPE_BLANC)
        coul = NOIR;
    else
        coul = BLANC;

    while (i<(int)numinter->size()) {
        abscisseInter = abscisse((*numinter)[i]);
        ordonneeInter = ordonnee((*numinter)[i]);
        nbLibertesBonus = 0;
        grps.resize(0);

        for (j=-1; j<=1; j+=2) { // -1 et 1
            for (k=0; k<=1; k++) {
                if (k==0) {
                    abscisseAdj = abscisseInter + j;
                    ordonneeAdj = ordonneeInter;
                } else {
                    abscisseAdj = abscisseInter;
                    ordonneeAdj = ordonneeInter + j;
                }

                if (g->dansPlateau(abscisseAdj, ordonneeAdj)) { // si l'intersection est dans le goban
                    if (g->getIntersection(abscisseAdj, ordonneeAdj)->couleur() == VIDE) // si l'intersection est vide
                        nbLibertesBonus += 1;
                    else if (g->getIntersection(abscisseAdj, ordonneeAdj)->couleur() == coul) { // meme couleur mais pas męme groupe
                        indiceGrps = 0;
                        grpActuel = g->getIntersection(abscisseAdj, ordonneeAdj)->getGroupe();
                        while (indiceGrps<(int)grps.size() && grps[indiceGrps]!=grpActuel)
                            indiceGrps++;

                        if (indiceGrps>=(int)grps.size()) { // groupe pas encore étudié
                            nbLibertesBonus += grpActuel->getNbLib()-1;
                            grps.push_back(grpActuel);
                            if (grpTrouve == false) { // on n'a pas encore trouvé de groupes de numgrp ŕ laquelle est rattachée cette intersection ... peut-ętre celui-lŕ
                                l=0;
                                while (l<(int)numgrp->size() && getGroupe((*numgrp)[l])!=grpActuel)
                                    l++;
                                if (getGroupe((*numgrp)[l])==grpActuel)
                                    grpTrouve = true;
                            }
                        }
                    }
                }
            }
        }
        if (nbLibertesBonus >= nblib && grpTrouve)
            i++;
        else
            numinter->erase(numinter->begin() + i);
    }
    return numinter->size()>0;

}

bool regles::Coin(vector<int> * listeCoins) { //réinitialise une liste de coins
    traceTemp+="Coin ";

    //on efface le contenu de la liste (quand on l'appelle c'est pour renvoyer tous les coins du goban)
    listeCoins->clear();
    //puis on rajoute chaque coin du goban.
    (*listeCoins).push_back(COININFGAUCHE);
    (*listeCoins).push_back(COINSUPGAUCHE);
    (*listeCoins).push_back(COININFDROIT);
    (*listeCoins).push_back(COINSUPDROIT);
    cout<<"liste des Coins :"<<endl;
    afficherVecteurInt(listeCoins);
    return true;
}

bool regles::Bord (vector<int> * listeBords) { //réinitialise une liste de bords
    traceTemp+="Bord ";

    //on efface le contenu de la liste (quand on l'appelle c'est pour renvoyer tous les bords du goban)
    listeBords->clear();
    //puis on rajoute chaque coin du goban.
    listeBords->push_back(BORDSUP);
    listeBords->push_back(BORDDROIT);
    listeBords->push_back(BORDINF);
    listeBords->push_back(BORDGAUCHE);
    cout<<"liste des Bords :"<<endl;
    afficherVecteurInt(listeBords);
    return true;
}

bool regles::intersection(vector<int> * listeI) {
    traceTemp+="Intersection ";
    int carre = g->getTaille() * g->getTaille();
    listeI->clear();
    listeI->resize(carre);
    //puis on rajoute chaque intersection du goban.
    for (int i =0; i <carre ; i++) {
        (*listeI)[i]=i;
    }
    cout<<"liste des Intersections :"<<endl;
    afficherVecteurInt(listeI);
    return true;
}

bool regles::BordLePlusVide(vector<int> * listeBords) { // retourne le ou les bords oů il y a le plus grand espace entre deux pierres
    traceTemp+="&& BordLePlusVide ";
    if (listeBords->size()==1)
        return true;

    int i=0, j, maxEspaceTotal=0, maxEspaceCeBord, espaceGauche, espaceDroite;
    vector<vector <int> > * pierresSurBord;
    Intersection* inter;
    cout<<"regles::BordLePlusVide(vector<int> * listeBords) : avant premier while"<<endl;
    while (i<(int)listeBords->size()) { // on parcourt les différents bords
        cout<<"regles::BordLePlusVide(vector<int> * listeBords) : premier while : i = "<<i<<" - listeBords->size() : " <<listeBords->size()<<endl;
        maxEspaceCeBord = 0;
        pierresSurBord = getZone((*listeBords)[i]);
        if ((int)(*pierresSurBord)[0].size() == 0) { // pas de pierres sur le bord
            inter = centreZone((*listeBords)[i]);
            if (inter->getPierreGauche() == NULL)
                espaceGauche = (g->getTaille()-1)/2;
            else
                espaceGauche = inter->getDistancePierreGauche();
            if (inter->getPierreDroite() == NULL)
                espaceDroite = (g->getTaille()-1)/2;
            else
                espaceDroite = inter->getDistancePierreDroite();
            maxEspaceCeBord = espaceGauche + espaceDroite + 1;
        } else {
            for (j=0; j<(int)(*pierresSurBord)[0].size(); j++) { // on étudie les différentes pierres du bord
                maxEspaceCeBord = 0;
                inter = g->getIntersection((*pierresSurBord)[0][j],(*pierresSurBord)[1][j]);
                if (inter->getDistancePierreGauche() == -1)
                    espaceGauche = g->getDistanceBordGauche(inter->getX(), inter->getY());
                else
                    espaceGauche = inter->getDistancePierreGauche();

                if (inter->getDistancePierreDroite() == -1)
                    espaceDroite = g->getDistanceBordDroit(inter->getX(), inter->getY());
                else
                    espaceDroite = inter->getDistancePierreDroite();

                maxEspaceCeBord = max(maxEspaceCeBord, max(inter->getDistancePierreGauche(), inter->getDistancePierreDroite()));
            }
        }

        if (maxEspaceCeBord<maxEspaceTotal) {
            cout<<"maxEspaceCeBord<maxEspaceTotal"<<endl;
            listeBords->erase(listeBords->begin()+i);
        } else if (maxEspaceCeBord == maxEspaceTotal) {
            cout<<"maxEspaceCeBord==maxEspaceTotal"<<endl;
            i++;
        } else { // maxEspaceCeBord > maxEspaceTotal
            cout<<"maxEspaceCeBord>maxEspaceTotal"<<endl;
            maxEspaceTotal = maxEspaceCeBord;
            for (j=0; j<i; j++) {
                listeBords->erase(listeBords->begin());
            }
            i = 1;
            cout<<"maxEspaceCeBord>maxEspaceTotal : i = "<<i<<" - listeBords->size() : " <<listeBords->size()<<endl;
        }
    }
    cout<<"liste des Bords les plus vides :"<<endl;
    afficherVecteurInt(listeBords);
    cout<<"fin de la liste des Bords les plus vides"<<endl;
    return ((int)listeBords->size()>0);
}

bool regles::CoinVide(vector<int> * listeCoins) {
    traceTemp+=" && CoinVide ";

    //cout<<"size : "<<listeCoins->size()<<endl;
    int i = 0;
    while (i<(int)listeCoins->size()) {
        cout<<"i : "<<i<<endl;
        cout<<"(*getZone((*listeCoins)[i]))[0].size() : "<<(int)(*getZone((*listeCoins)[i]))[0].size()<<endl;
        if ((int)(*getZone((*listeCoins)[i]))[0].size() > 0 ) { // nombre de pierres dans le coin
            cout<<"Hum, il y a une pierre en ("<<(*getZone((*listeCoins)[i]))[0][0]<<";"<<(*getZone((*listeCoins)[i]))[1][0]<<"), le coin "<<(*listeCoins)[i]<<" n'est donc pas vide"<<endl;
            listeCoins->erase(listeCoins->begin()+i);
        } else {

            cout<<"Le coin "<<(*listeCoins)[i]<<" est vide"<<endl;
            for (int j=0; j<(int)(*getZone((*listeCoins)[i]))[0].size(); j++) {
                cout<<(*getZone((*listeCoins)[i]))[0].size()<<endl;
            }
            i++;
        }
    }
    cout<<"liste des Coins vides :"<<endl;
    afficherVecteurInt(listeCoins);
    cout<<"fin de la liste des Coins vides"<<endl;
    return listeCoins->size()>0;
}

bool regles::appartientabord(vector<int> * listeCoins, vector<int> * listeBords) {
    traceTemp+=" && appartientabord ";
    // on considčre que la valeur des bords se trouve entre 0 et 9
    // on repčre les bords ŕ ajouter
    int i;
    vector<bool> bordAjoute;
    for (i=0; i<4; i++)
        bordAjoute.push_back(false); // sup : 0 , droite : 1, bas : 2, gauche : 3
    for (i=0; i<(int)listeCoins->size(); i++) {
        switch ((*listeCoins)[i]) {
        case COININFGAUCHE:
            bordAjoute[2] = true;
            bordAjoute[3] = true;
            break;

        case COINSUPGAUCHE:
            bordAjoute[0] = true;
            bordAjoute[3] = true;
            break;

        case COININFDROIT:
            bordAjoute[2] = true;
            bordAjoute[1] = true;
            break;

        case COINSUPDROIT:
            bordAjoute[0] = true;
            bordAjoute[1] = true;
            break;
        }
    }

    // on ajoute les bords dans la liste
    i=0;
    int case_tableau;
    while (i<(int)listeBords->size()) { // on parcourt la liste des bords
        switch ((*listeBords)[i]) {
        case BORDSUP :
            case_tableau = 0;
            break;

        case BORDDROIT :
            case_tableau = 1;
            break;

        case BORDINF :
            case_tableau = 2;
            break;

        case BORDGAUCHE :
            case_tableau = 3;
            break;

        default :
            case_tableau = 0;
            cout<<"erreur/error dans appartientAbord pour casetableau"<<endl;
            break;

        }

        if (bordAjoute[case_tableau]) // ce bord correspond
            i++;
        else
            listeBords->erase(listeBords->begin()+i);
    }

    cout<<"liste des Bords appartenants ŕ un des coins vides :"<<endl;
    afficherVecteurInt(listeBords);
    return i>0;

}

bool regles::joseki(vector<int> * listeCoins) { //renvoie vrai s'il existe un joseki dans un des coins, et enlčve les coins de c ne contenant pas de joseki
    traceTemp+=" && Joseki ";
    bool retour = false;
    int i;
    vector<vector <int> > * coups_coin;
    vector<vector <int> > liste_coups, tableauInutile;

    liste_coups.resize(2);
    tableauInutile.resize(TAILLE_JOSEKI);
    for (i=0; i<TAILLE_JOSEKI; i++)
        tableauInutile[i].resize(TAILLE_JOSEKI);
    i=0;
    while (!retour and i < (int)listeCoins->size()) {

//        cout<<"on va zyeuter listeCoins[i] qui vaut:"<<endl;
        cout<<(*listeCoins)[i]<<endl;
        coups_coin = getcoinJoseki((*listeCoins)[i]);
        if(alternerNoirBlanc(coups_coin,&liste_coups)){

            // on ordonne les coups pour les envoyer ŕ la fonction chercherPosition2 de DicoJoseki
            if (monIa->getDicoJoseki()->chercherPosition2(&liste_coups, &tableauInutile)) // il existe un joseki dans ce coin
                i++;
            else // pas de joseki dans ce coin
                listeCoins->erase(listeCoins->begin()+i);
        }
    }
//    cout<<"liste des Coins dans lesquels on peut jouer un joseki :"<<endl;
    afficherVecteurInt(listeCoins);
    return i>0;
}


bool regles::BordVide(vector<int> * listeBords) {
    traceTemp+=" && BordVide ";
    //cout<<"size : "<<listeBords->size()<<endl;
    int i = 0;
    while (i<(int)listeBords->size()) {
        if ((int)(*getZone((*listeBords)[i]))[0].size() > 0 ) { // nombre de pierres dans le coin
            //cout<<(*getZone((*listeBords)[i]))[0].size()<<endl;
            //cout<<"b : "<<i<<endl;
            listeBords->erase(listeBords->begin()+i);
        } else
            i++;
    }
    cout<<"liste des Bords vides :"<<endl;
    afficherVecteurInt(listeBords);
    cout<<"fin de la liste des Bords vides"<<endl;
    return ((int)listeBords->size()>0);
}

bool regles::groupe (vector<int> * listeGroupes) { // initialise la liste avec les groupes tout les groupes.
    traceTemp+="groupe ";
    //on efface le contenu de la liste (quand on l'appelle c'est pour renvoyer tous les groupes du goban)
    listeGroupes->clear();

    int tailleN = g->getListeGroupeN()->size(), tailleB = g->getListeGroupeB()->size(), i;
    listeGroupes->resize(tailleB + tailleN);
    /*cout<<"tailleN : "<<tailleN<<endl;
    cout<<"tailleB : "<<tailleB<<endl;
    cout<<"tailleN + tailleB : "<<tailleN + tailleB<<endl;*/
    for (i=0; i<tailleN; i++)
        (*listeGroupes)[i] = GROUPE_NOIR + i;

    for (i=tailleN; i<tailleN + tailleB; i++)
        (*listeGroupes)[i] = GROUPE_BLANC + i - tailleN;

    return i>0;
}

bool regles::GroupeN (vector<int> * listeGroupes) { // initialise la liste avec les groupes noirs si elle est vide, vire les groupes blancs sinon
    traceTemp+=" && GroupeN ";
    int i;
    int taille = listeGroupes->size();
    cout<<"GroupeN : taille : "<<taille<<endl;
    if (taille == 0) { // on remplit listeGroupe avec les groupes noirs
        taille = g->getListeGroupeN()->size();
        if (taille == 0)
            return false;
        else {
            listeGroupes->resize(taille);
            for (i=0 ; i<taille ; i++)
                (*listeGroupes)[i] = GROUPE_NOIR + i;
        }
    } else { // on vire les groupes blancs
        i=0;
        while (i<(int)listeGroupes->size()) {
            if ((*listeGroupes)[i]>=GROUPE_BLANC) // groupe blanc
                listeGroupes->erase(listeGroupes->begin()+i);
            else
                i++;
        }
    }
    cout<<"fin de groupe N : liste des groupes :"<<endl;
    afficherVecteurInt(listeGroupes);
    cout<<"fin de groupe N : fin"<<endl;
    return i>0;
}

bool regles::GroupeB (vector<int> * listeGroupes) { // initialise une liste des groupes
    traceTemp+=" && GroupeB ";
    int i;
    int taille = listeGroupes->size();
    if (taille == 0) { // on remplit listeGroupe avec les groupes blancs
        taille = g->getListeGroupeB()->size();
        if (taille == 0)
            return false;
        else {
            listeGroupes->resize(taille);
            for (i=0 ; i<taille ; i++)
                (*listeGroupes)[i] = GROUPE_BLANC + i;
        }
    } else { // on vire les groupes noirs
        i=0;
        while (i<(int)listeGroupes->size()) {
            if ((*listeGroupes)[i]<GROUPE_BLANC) // groupe noir
                listeGroupes->erase(listeGroupes->begin()+i);
            else
                i++;
        }
    }
    return i>0;
}

bool regles::PierreN(vector<int> * listeInter) { // vire les intersections ne contenant pas de pierres noires
    traceTemp+=" && PierreN ";
    cout<<"Début PierreN()"<<endl;
    int i=0;
    while (i<(int)listeInter->size()) {
        if (g->getIntersection(abscisse((*listeInter)[i]), ordonnee((*listeInter)[i]))->couleur() == NOIR) {
            i++;
            cout<<i<<endl;
            cout<<"L'intersection ("<<abscisse((*listeInter)[i])<<";"<<ordonnee((*listeInter)[i])<<") contient une pierre noire et est donc conservée"<<endl;
        } else {
            listeInter->erase(listeInter->begin()+i);
        }
    }
    cout<<"Fin PierreN() : taille : "<<listeInter->size()<<endl;
    return listeInter->size()>0;
}

bool regles::PierreB(vector<int> * listeInter) { // vire les intersections ne contenant pas de pierres blanches
    traceTemp+=" && PierreB ";
    cout<<"Début PierreB()"<<endl;
    int i=0;
    while (i<(int)listeInter->size()) {
        if (g->getIntersection(abscisse((*listeInter)[i]), ordonnee((*listeInter)[i]))->couleur() == BLANC) {
            i++;
            cout<<"L'intersection ("<<abscisse((*listeInter)[i])<<";"<<ordonnee((*listeInter)[i])<<") contient une pierre blanche et est donc conservée"<<endl;
        } else
            listeInter->erase(listeInter->begin()+i);
    }
    cout<<"Fin PierreB() : taille : "<<listeInter->size()<<endl;
    return listeInter->size()>0;
}

/*bool regles::superGroupe (vector<int> * listeSuperGroupes)  // réinitialise une liste avec tous les supergroupes
{
    //on efface le contenu de la liste (quand on l'appelle c'est pour renvoyer tous les groupes du goban)
    listeSuperGroupes->clear();

    int tailleN = g->getListeSuperGroupeN()->size(), tailleB = g->getListeSuperGroupeB()->size(), i;
    listeSuperGroupes->resize(tailleB + tailleN);
    for(i=0; i<tailleN; i++)
        (*listeSuperGroupes)[i] = SUPERGROUPE_NOIR + i;

    for(i=tailleN; i<tailleN + tailleB; i++)
        (*listeSuperGroupes)[i] = SUPERGROUPE_BLANC + i - tailleN;

    return i>0;
}

bool regles::SuperGroupeN (vector<int> * listeSuperGroupes) // initialise la liste avec les supergroupes noirs si elle est vide, vire les groupes blancs sinon
{
    int i;
    int taille = listeSuperGroupes->size();
    if(taille == 0) // on remplit listeGroupe avec les supergroupes noirs
    {
        taille = g->getListeSuperGroupeN()->size();
        if(taille == 0)
            return false;
        else
        {
            listeSuperGroupes->resize(taille);
            for(i=0 ; i<taille ; i++)
                (*listeSuperGroupes)[i] = SUPERGROUPE_NOIR + i;
        }
    }
    else // on vire les supergroupes blancs
    {
        i=0;
        while(i<listeSuperGroupes->size())
        {
            if((*listeSuperGroupes)[i]>=SUPERGROUPE_BLANC) // supergroupe blanc
                listeSuperGroupes->erase(listeSuperGroupes->begin()+i);
            else
                i++;
        }
    }
    return i>0;
}

bool regles::SuperGroupeB (vector<int> * listeSuperGroupes) // initialise la liste avec les supergroupes blancs si elle est vide, vire les groupes noirs sinon
{
    int i;
    int taille = listeSuperGroupes->size();
    if(taille == 0) // on remplit listeSuperGroupe avec les supergroupes blancs
    {
        taille = g->getListeSuperGroupeB()->size();
        if(taille == 0)
            return false;
        else
        {
            listeSuperGroupes->resize(taille);
            for(i=0 ; i<taille ; i++)
                (*listeSuperGroupes)[i] = SUPERGROUPE_BLANC + i;
        }
    }
    else // on vire les supergroupes noirs
    {
        i=0;
        while(i<listeSuperGroupes->size())
        {
            if((*listeSuperGroupes)[i]<SUPERGROUPE_BLANC) // supergroupe noir
                listeSuperGroupes->erase(listeSuperGroupes->begin()+i);
            else
                i++;
        }
    }
    return i>0;
}*/

bool regles::ligne (vector<int> * listeLignes) { //réinitialise une liste des lignes
    traceTemp+="ligne ";
    listeLignes->resize(abscisseTengen() + 1);
    for (int i=0; i<=abscisseTengen(); i++)
        (*listeLignes)[i] = i;
    return 1;
}

bool regles::lignes(vector<int> * listeLignes, int numLigne) { // supprime toutes les lignes différentes de numLigne
    traceTemp+=" && ligne(";
    traceTemp+=(numLigne+48);
    traceTemp+=" )";
    bool trouve=false;
    int i=0;
    while (i<(int)listeLignes->size() and !trouve) {
        if ((*listeLignes)[i] == numLigne)
            trouve = true;
        else
            i++;
    }
    if (trouve) {
        listeLignes->resize(1);
        (*listeLignes)[0] = numLigne;
    } else
        listeLignes->resize(0);
    return trouve;
}

bool regles::libertes(vector<int> * groupes, int libertes) { // supprime les groupes ayant au moins [libertes] libertés de la liste, retourne false si la liste est vide ŕ la fin
    traceTemp+=" && libertes ( ";
    traceTemp+=libertes+48;
    traceTemp+="  ) ";
    int i=0;
    cout<<"nombre de groupes noirs sur le goban : "<<g->getListeGroupeN()->size()<<endl;
    cout<<"nombre de groupes blancs sur le goban : "<<g->getListeGroupeB()->size()<<endl;
    cout<<"nombre de groupes : "<<groupes->size()<<endl;
    while (i<(int)groupes->size()) {
        cout<<"groupe "<<(*groupes)[i]<<endl;
        if ((*groupes)[i]<GROUPE_BLANC) { // le groupe est noir
            cout<<"groupe noir numero "<<(*groupes)[i]-GROUPE_NOIR<<endl;
            if ((*(g->getListeGroupeN()))[(*groupes)[i]-GROUPE_NOIR]->getNbLib() >= libertes) // si le groupe a trop de libertés
                groupes->erase(groupes->begin()+i);
            else
                i++;
        } else { // le groupe est blanc
            cout<<"groupe blanc numero "<<(*groupes)[i]-GROUPE_BLANC<<endl;
            if ((*(g->getListeGroupeB()))[(*groupes)[i]-GROUPE_BLANC]->getNbLib()>=libertes) // si le groupe a trop de libertés
                groupes->erase(groupes->begin()+i);
            else
                i++;
        }
    }
    cout<<"fin de bool regles::libertes(vector<int> * groupes, int libertes)"<<endl;
    return i>0;
}

bool regles::libertesInterN(vector<int> * inter, int lib) { // élimine les intersections ayant moins de lib libertes, la couleur considérée est celle de l'IA
    traceTemp+=" && libertesInterN( ";
    traceTemp+=lib+48;
    traceTemp+=" ) ";

    cout<<"Debut de libertesInterN(inter, lib) : taille : inter->size()"<<endl;
    int i=0, absc, ord;
    char couleur = NOIR;
    while (i<(int)inter->size()) {
        absc = abscisse((*inter)[i]);
        ord = ordonnee((*inter)[i]);
        cout<<"intersection ("<<absc<<","<<ord<<") : "<<endl;
        if (g->caseJouable(absc, ord, couleur) == false){
            inter->erase(inter->begin()+i);
            cout<<"Case injouable"<<endl;
        } else {
            Goban gob(g);
            gob.poserPierreLite(couleur, absc, ord);
            if (gob.getIntersection(absc, ord)->getGroupe()->getNbLib() < lib) {
                cout<<"L'intersection en ("<<absc<<";"<<ord<<") n'offrirait que "<<gob.getIntersection(absc, ord)->getGroupe()->getNbLib()<<" libertés ŕ "<<couleur<<" et est donc rejetée"<<endl;
                inter->erase(inter->begin()+i);
            } else {
                cout<<"L'intersection en ("<<absc<<";"<<ord<<") offrirait "<<gob.getIntersection(absc, ord)->getGroupe()->getNbLib()<<" libertés ŕ "<<couleur<<" et est donc retenue"<<endl;
                i++;
            }
        }
    }
    cout<<"Fin de libertesInterN"<<endl;
    return inter->size()>0;
}

bool regles::libertesInterB(vector<int> * inter, int lib) { // élimine les intersections ayant moins de lib libertes
    traceTemp+=" && libertesInterB ";

    cout<<"Debut de libertesInter(inter, lib)"<<endl;
    int i=0, absc, ord;
    char couleur = BLANC;
    while (i<(int)inter->size()) {
        Goban gob(g);
        absc = abscisse((*inter)[i]);
        ord = ordonnee((*inter)[i]);
        gob.poserPierre(couleur, absc, ord);
        if (gob.caseJouable(absc, ord, couleur) == false) {
            inter->erase(inter->begin()+i);
        }
        if (gob.getIntersection(absc, ord)->getGroupe()->getNbLib() < lib) {
            cout<<"L'intersection en ("<<absc<<";"<<ord<<") n'offrirait que "<<gob.getIntersection(absc, ord)->getGroupe()->getNbLib()<<" libertés ŕ "<<couleur<<" et est donc rejetée"<<endl;
            inter->erase(inter->begin()+i);
        } else {
            cout<<"L'intersection en ("<<absc<<";"<<ord<<") offrirait "<<gob.getIntersection(absc, ord)->getGroupe()->getNbLib()<<" libertés ŕ "<<couleur<<" et est donc retenue"<<endl;
            i++;
        }
    }
    cout<<"Fin de libertesInter"<<endl;
    return inter->size()>0;
}



//enleve tous les groupes qui n'ont pas une liberté qui est une intersction de la liste et toutes les intersections qui ne sont pas des libertés dans des groupes
bool regles::liberteGroupe(vector<int> * intersections, vector<int> * groupes) {
    traceTemp+=" && libertes ";

    //cout<<"LIBERTEGROUPE!!!!"<<endl;

    bool trouve;
    for (int j = 0; j < (int)intersections->size(); j++) {
        int i=0;
        trouve = false;
        while (i<(int)groupes->size()&& !trouve) {
            //le groupe est blancs
            if ((*groupes)[i]>=GROUPE_BLANC) {
                if ((*(g->getListeGroupeB()))[(*groupes)[i]-GROUPE_BLANC]->findLiberte(abscisse((*intersections)[j]), ordonnee((*intersections)[j])) ) {
                    trouve=true;
                }
            } else { //le groupe est noir
                if ((*(g->getListeGroupeN()))[(*groupes)[i]-GROUPE_NOIR]->findLiberte(abscisse((*intersections)[j]), ordonnee((*intersections)[j])) ) {
                    trouve=true;
                }
            }
            i++;
        }
        cout<<"intersection: "<<abscisse((*intersections)[j])<<" - "<<ordonnee((*intersections)[j])<< "trouve: "<<trouve<<endl;
        if (!trouve) {
            intersections->erase(intersections->begin()+j);
            j--;
        }
    }
    for (int j = 0; j < (int)groupes->size(); j++) {
        int i=0;
        trouve = false;
        while (i<(int)intersections->size()&& !trouve) {
            //le groupe est blancs
            if ((*groupes)[j]>=GROUPE_BLANC) {
                if ((*(g->getListeGroupeB()))[(*groupes)[j]-GROUPE_BLANC]->findLiberte(abscisse((*intersections)[i]), ordonnee((*intersections)[i])) ) {
                    trouve=true;
                }
            } else { //le groupe est noir
                if ((*(g->getListeGroupeN()))[(*groupes)[j]-GROUPE_NOIR]->findLiberte(abscisse((*intersections)[i]), ordonnee((*intersections)[i])) ) {
                    trouve=true;
                }
            }
            i++;
        }
        if (!trouve) {
            groupes->erase(groupes->begin()+j);
            j--;
        }
    }
//cout<<"FIN LIBERTE GROUPE"<<endl;
    return groupes->size()>0;
}




bool regles::nbPierres(vector<int> * groupes, int pierres) { // supprime les groupes ayant de moins de pieres que [pierres] retourne false si la liste est vide ŕ la fin
    traceTemp+=" && nbPierres > ";
    traceTemp+=pierres;

    int i=0;
    /*cout<<"nombre de groupes noirs sur le goban : "<<g->getListeGroupeN()->size()<<endl;
    cout<<"nombre de groupes blancs sur le goban : "<<g->getListeGroupeB()->size()<<endl;
    cout<<"nombre de groupes : "<<groupes->size()<<endl;*/
    while (i<(int)groupes->size()) {
        //cout<<"groupe "<<(*groupes)[i]<<endl;
        if ((*groupes)[i]<GROUPE_BLANC) { // le groupe est noir
            //cout<<"groupe noir numero "<<(*groupes)[i]-GROUPE_NOIR<<endl;
            if ((*(g->getListeGroupeN()))[(*groupes)[i]-GROUPE_NOIR]->getNbPierres() < pierres) // si le groupe a moins de libertés que demandé
                groupes->erase(groupes->begin()+i);
            else
                i++;
        } else { // le groupe est blanc
            //cout<<"groupe blanc numero "<<(*groupes)[i]-GROUPE_BLANC<<endl;
            if ((*(g->getListeGroupeB()))[(*groupes)[i]-GROUPE_BLANC]->getNbPierres() < pierres) // si le groupe a moins de libertés que demandé
                groupes->erase(groupes->begin()+i);
            else
                i++;
        }
    }
    //cout<<"fin de bool regles::libertes(vector<int> * groupes, int libertes)"<<endl;
    return i>0;
}

bool regles::momentPartie(int moment) { // retoure vrai si on est dans la période de la partie indiquée
    traceTemp+=" && (momentParties = ";
    traceTemp+=moment;

    machiaFait instant;
    instant.id = moment;
    instant.args.resize(0);
    return testerFait(instant);
}

bool regles::nbcoupsjoues(int nb) { // indique si au moins nb coups ont été joués
    traceTemp+=" && nbCoupsJoues >";
    traceTemp+=(char)nb;

    return (int)g->getHistorique().size() >= nb;
}


bool regles::shisho(vector<int> * groupes) {
    traceTemp+=" && Shisho ";

    int i=0;
    int j=0;
    while (i<(int)groupes->size()) {
        Goban * g1 = new Goban(g);
        string sTemp = "\n \n ++++++++++++++++++ \n  nouveau Shisho  \n ++++++++++++++++++  \n \n";
        g1->setTrace("shishoERR.txt");
        g->trace("shisho.txt",1,1,&sTemp);
        //g1->write("début d'un nouveau shisho");
        Goban * g2 = new Goban(g);
        g2->setTrace("shishoERR.txt");
        //g2->write("début d'un nouveau shisho");
        if ((*groupes)[i]>=GROUPE_BLANC) { // le groupe est noir
            cout<<"shisho ORIGINEL ! ! ! ! "<<endl;
            cout<<"trace : nbLib : "<<(*(g->getListeGroupeB()))[(*groupes)[i]-GROUPE_BLANC]->getNbLib()<<endl;
           /* if (!(
                (
                    ((*(g->getListeGroupeB()))[(*groupes)[i]-GROUPE_BLANC]->getNbLib()==2)
                    &&
                    shisho2(g1, (*(g1->getListeGroupeB()))[(*groupes)[i]-GROUPE_BLANC])
                )||(
                    ((*(g->getListeGroupeB()))[(*groupes)[i]-GROUPE_BLANC]->getNbLib()==1)
                    &&
                    shisho1(g2,(*(g2->getListeGroupeB()))[(*groupes)[i]-GROUPE_BLANC])
                )
            )) {
                groupes->erase(groupes->begin()+i);
                j++;
            } else {
                i++;
            }
            */
            //LA PARTIE AU DESSUS SEGFAULT!
            //remplacement:
            bool bTemp=false;
            if((*(g->getListeGroupeB()))[(*groupes)[i]-GROUPE_BLANC]->getNbLib()==2){
                cout<<"pre S2"<<endl;
                bTemp+=shisho2(g1, (*(g1->getListeGroupeB()))[(*groupes)[i]-GROUPE_BLANC]);
                cout<<"post S2"<<endl;
            }
            if(bTemp==0 && (*(g->getListeGroupeB()))[(*groupes)[i]-GROUPE_BLANC]->getNbLib()==1){
                cout<<"pre S1"<<endl;
                shisho1(g2,(*(g2->getListeGroupeB()))[(*groupes)[i]-GROUPE_BLANC]);
                cout<<"post S1"<<endl;
            }
            if(!bTemp){
                groupes->erase(groupes->begin()+i);
                j++;
            } else {
                i++;
            }
        } else { // le groupe est blanc
            if (!( (((*(g->getListeGroupeN()))[(*groupes)[i]-GROUPE_NOIR]->getNbLib()==2) && shisho2(g1, (*(g1->getListeGroupeN()))[(*groupes)[i]-GROUPE_NOIR]) ) ||
                    (((*(g->getListeGroupeN()))[(*groupes)[i]-GROUPE_NOIR]->getNbLib()==1) && shisho1(g2,(*(g2->getListeGroupeN()))[(*groupes)[i]-GROUPE_NOIR])))) {
                groupes->erase(groupes->begin()+i);
                j++;
            } else {
                i++;
            }
        }
        delete g1;
        delete g2;
    }
    cout<<i<<" groupes pris dans des shishos !"<<endl;
    return i>0;
}


bool regles::atari(Coup cp, Goban * g) {

    char c2= couleurOppose(cp.c);
    int x = cp.x;
    int y = cp.y;
    if ( (g->getIntersection(x-1,y)->couleur() == c2 && g->getIntersection(x-1,y)->getGroupe()->getNbLib() < 2) ||
            (g->getIntersection(x,y-1)->couleur() == c2 && g->getIntersection(x,y-1)->getGroupe()->getNbLib() < 2) ||
            (g->getIntersection(x+1,y)->couleur() == c2 && g->getIntersection(x+1,y)->getGroupe()->getNbLib() < 2) ||
            (g->getIntersection(x,y+1)->couleur() == c2 && g->getIntersection(x,y+1)->getGroupe()->getNbLib() < 2)) {
        return true;
    } else {
        return false;
    }
}


//prend un groupe qui a une liberté
bool regles::shisho1(Goban * g1,Groupe * gp) {
    cout<<"shisho1 ! ! ! ! "<<endl;
    cout<<"trace : nbLib : "<<gp->getNbLib()<<endl;
    Groupe * gr2;
    string sTemp = "Shisho1";
    g1->trace("shisho.txt",1,1,&sTemp);
    Coup cp;
    g1->afficher();
    //cout<<gp->getNbLib()<<endl;
    cp.x = gp->getLibertes(0).x;
    cp.y = gp->getLibertes(0).y;
    cp.c = gp->getCouleur();
    cout<<(int)cp.x<<" - "<<(int)cp.y<<endl;
    if (!g1->caseJouable(cp)) {
        return true;
    } else {
        sTemp="TRACE BEFORE :";
        g1->trace("shisho.txt",1,1,&sTemp);
        //cout<<"TRACE : NBLIB BEFORE! : "<<(*(gp->getLibertes())).size()<<" / "<<gp->getNbLib()<<endl;
        g1->poserPierreLite(cp);
        sTemp="TRACE AFTER :";
        g1->trace("shisho.txt",1,1,&sTemp);
        //g1->poserPierre(cp);
        gr2= (g1->getIntersection(cp.x, cp.y)->getGroupe());
        //cout<<"TRACE : NBLIB AFTER : "<<(*(gr2->getLibertes())).size()<<" / "<<gr2->getNbLib()<<endl;
        if (atari(cp,g1)) {
            cout<<"atari!"<<endl;
            return false;
        } else {
            cout<<"shisho1.4 ! ! ! ! "<<endl;
            g1->afficher();
            cout<<"fin shisho1"<<endl;
            return shisho2(g1, gr2);
        }
    }
}


//prend un groupe qui a 2 libertés
bool regles::shisho2(Goban * g1,Groupe * gp) {
    string sTemp = "Shisho2";
    g1->trace("shisho.txt",1,1,&sTemp);
    cout<<"shisho2 ! ! ! ! "<<endl;
    cout<<"trace : nbLib : "<<gp->getNbLib()<<endl;
    g1->afficher();
    if (gp->getNbLib()==2) {
        bool retour = false;
        //g2->afficher();
        Coup cp, cp2, cpG; //cp et cp2 sont les coups sur les libertés. cpG est une des pierres du groupe.
        cp.x = gp->getLibertes(0).x;
        cp.y = gp->getLibertes(0).y;
        cp2.x = gp->getLibertes(1).x;
        cp2.y = gp->getLibertes(1).y;
        cpG.x = (*(gp->getListe()))[0]->getX();
        cpG.y = (*(gp->getListe()))[0]->getY();
        cout<<(int)cp.x<<" - "<<(int)cp.y<<endl;
        cp.c = couleurOppose(gp->getCouleur());
        if(g1->caseJouable(cp)){
            g1->poserPierreLite(cp);
            //g1->afficher();
            retour = shisho1(g1, gp);
        }
        if(!retour ){
            Goban * g2 = new Goban(g1);

            //cout<<" TRACE R1 : "<<gp->getListe()->size()<<endl;
            //cout<<" TRACE R2 : "<<(*(gp->getListe()))[0]->getX()<<endl;
            Groupe * Gp2 = g2->getIntersection(cpG.x ,cpG.y)->getGroupe();
            cp2.c = couleurOppose(gp->getCouleur());
            cout<<(int)cp2.x<<" - "<<(int)cp2.y<<endl;
            if(g2->caseJouable(cp2)){
                g2->poserPierreLite(cp2);
                //g2->afficher();
                retour += shisho1(g2,Gp2 );
            }
           // cout<<"appel shisho1"<<endl;
           // bool b = shisho1(g2, g2->getIntersection(gp->getListe()[0]->getX(),gp->getListe()[0]->getY())->getGroupe()) || shisho1(g1, gp); //A RETOUCHER  ! ! ! !
            delete g2;
        }
        cout<<"fin shisho2"<<endl;
        return retour;
    } else {
        cout<<"sortie des conditions..."<<gp->getNbLib()<<endl;
        return (gp->getNbLib() < 2);
    }
}

bool regles::surLigne(vector<int> * inter, int numligne) {
    /*
    traceTemp+=" && surLigne( ";
    traceTemp+=numligne+48;
    traceTemp+=" ) ";
    */

    cout<<"Début de surLigne"<<endl;
    int i=0, x, y;
    while (i<(int)inter->size()) {
        x = abscisse((*inter)[i]);
        y = ordonnee((*inter)[i]);
        if ((x == numligne || y == numligne || x == g->getTaille()-1-numligne || y == g->getTaille()-1-numligne) && x>=numligne  && y>=numligne && x <= g->getTaille()-1-numligne && y <= g->getTaille()-1-numligne) {
            i++;
            cout<<"l'intersection ("<<x<<";"<<y<<") est sur la ligne "<<numligne<<" et est donc conservée"<<endl;
        } else
            inter->erase(inter->begin()+i);
    }
    cout<<"regles::surLigne : taille de inter : "<<inter->size()<<endl;
    return inter->size()>0;
}

void regles::J_shisho(vector<vector<int> > arguments, regles * r, int poids) {
    cout<<"J_Shisho!"<<endl;
    int taille = arguments[0].size();
    Groupe * grp;
    int i;
    char couleur;
    vector<vector<int> > * p = r->getPoids();

    for (i=0; i<taille; i++) {
        if (arguments[0][i]<GROUPE_BLANC) { // groupe noir
            if ((arguments[0][i] -GROUPE_NOIR) >= (int)(*(r->getGoban()->getListeGroupeN())).size()) {
                cout<<"ERROR : ERREUR DANS LE CHOIX DU GROUPE NOIR : "<<arguments[0][i] -GROUPE_NOIR<<endl;
                grp = 0;
            } else {
                cout<<"gp : n "<<arguments[0][i] - GROUPE_NOIR<<endl;
                grp = (*(r->getGoban()->getListeGroupeN()))[arguments[0][i]-GROUPE_NOIR];
                couleur = NOIR;
            }
        } else { //groupe blanc
            if ((arguments[0][i] -GROUPE_BLANC) >= (int)(*(r->getGoban()->getListeGroupeB())).size()) {
                cout<<"ERROR : ERREUR DANS LE CHOIX DU GROUPE BLANC : "<<arguments[0][i] -GROUPE_BLANC<<endl;
                grp = 0;
            } else {
                cout<<"gp : b "<<arguments[0][i] - GROUPE_BLANC<<endl;
                grp = (*(r->getGoban()->getListeGroupeB()))[arguments[0][i]-GROUPE_BLANC];
                couleur = BLANC;
            }
        }

        if (grp->getNbLib()==2) {

            //        if (grp.getNbLib()==1){r->getGoban(); shisho1(grp);}
            Coup lib1;
            lib1.x = grp->getLibertes(0).x ;
            lib1.y = grp->getLibertes(0).y;
            lib1.c='n';
            Coup lib2;
            lib2.x = grp->getLibertes(1).x ;
            lib2.y = grp->getLibertes(1).y;
            lib2.c='n';

            //on crée des copies locales du goban.
            Goban * g1 = new Goban(r->getGoban());
            Goban * g2 = new Goban(r->getGoban());
            //on bouche une liberté sur chaque goban.
            string sTemp = "J_Shisho : lib1 :";
            sTemp+=lib1.x;
            sTemp+=" - ";
            sTemp+=lib1.y;
            sTemp+=" / Lib2 : ";
            sTemp+=lib2.x;
            sTemp+=" - ";
            sTemp+=lib2.y;

            bool b = false;

            r->getGoban()->trace("Jsihso.txt",1,1,&sTemp);
            if(r->getGoban()->caseJouable(lib1)){
                g1->poserPierreLite(lib1);
                Groupe * gp1 = g1->getIntersection((*(grp->getListe()))[0]->getX(),(*(grp->getListe()))[0]->getY())->getGroupe() ;
                if (r->shisho1(g1,gp1)) {
                    (*p)[lib1.x][lib1.y] += (grp->getNbPierres() * poids);
                    cout<<"shisho validé"<<endl;
                    b = true;
                }
            }
            if(r->getGoban()->caseJouable(lib2)){
                g2->poserPierreLite(lib2);
                Groupe * gp2 = g2->getIntersection((*(grp->getListe()))[0]->getX(),(*(grp->getListe()))[0]->getY())->getGroupe();
                if (r->shisho1(g2,gp2)) {
                    (*p)[lib2.x][lib2.y] += (grp->getNbPierres() * poids);
                    cout<<"shisho validé"<<endl;
                    b = true;
                }
            }
/*
            Groupe * gp1 = g1->getIntersection((*(grp->getListe()))[0]->getX(),(*(grp->getListe()))[0]->getY())->getGroupe() ;
            Groupe * gp2 = g2->getIntersection((*(grp->getListe()))[0]->getX(),(*(grp->getListe()))[0]->getY())->getGroupe();


            if (r->shisho1(g1,gp1)) {
                (*p)[lib1.x][lib1.y] += (grp->getNbPierres() * poids);
                cout<<"shisho validé"<<endl;
                b = true;
            }

            if (r->shisho1(g2,gp2)) {
                (*p)[lib2.x][lib2.y] += (grp->getNbPierres() * poids);
                cout<<"shisho validé"<<endl;
                b = true;
            }

            */
            if (b== false) {
                cout<<"ERREUR ! : Shisho non RETROUVE"<<endl;
            }

            delete g1;
            delete g2;
        } else if (grp->getNbLib()==1) {
            int lib1x = grp->getLibertes(0).x ;
            int lib1y = grp->getLibertes(0).y;
            (*p)[lib1x][lib1y] += (grp->getNbPierres() * poids);

        } else {
            cout<<"ERREUR sur nb liberté du groupe en shisho!!!!"<<endl;
        }

    }

}

/*bool regles::Shicho1lib(int numInterPierreAgressee) // retourne vrai si le shicho fonctionne
{
	Groupe * grp = g->getIntersection(abscisse(numInterPierreAgressee), ordonnee(numInterPierreAgressee))->getGroupe();
	if(grp->getNbLib() > 1)
		return false;
	else if(!(g->caseJouable((*(grp->getLibertes()))[0][0]), (*(grp->getLibertes()))[0][1], grp->getCouleur())) // si la liberte est une case de suicide
		return true
	else // deux libertés
	{
		Goban gob = new Goban(g);
		gob.poserPierre(grp->getCouleurOpposee(), )
		grp = g->getIntersection(abscisse(numInterPierreAgressee), ordonnee(numInterPierreAgressee))->getGroupe();
		return ShichoRecursif(grp);
	}
}

bool regles::ShichoRecursif(Groupe * grp)
{
	// grp n'a qu'une liberté qui est jouable
	if(gob_test->caseJouable()
	gob_test.poserPierre(grp->getCouleur(), (*grp->getLibertes())[0][0], (*grp->getLibertes())[1][0]);
	grp = g->getIntersection(abscisse(numInterPierreAgressee), ordonnee(numInterPierreAgressee))->getGroupe();
	switch(grp->getNbLib())
	{
		case 3 :
			return false;

	}
}
*/
//fonctions conclusion:

bool regles::Tengen(vector<int> * intersections) { // supprime les intersections ne correspondant pas au tengen, retourne faux si le tengen n'est pas dans la liste

    bool retour = false;
    int i = 0, tengen = numInterTengen();
    cout<<"tengen : "<<tengen<<endl;
    while (i<(int)intersections->size() && retour == false) {
        if ((*intersections)[i] == tengen) // Tengen
            retour = true;
        else
            i++;
    }
    if (retour == true) {
        intersections->resize(1);
        (*intersections)[0] = tengen;
    } else
        intersections->resize(0);

    return retour;
}

bool regles::tobi(vector<int> * listeInterA, vector<int> * listeInterB) { // supprime les éléments de chaque liste ne permettant pas de faire un tobi avec un élément de l'autre liste;
    traceTemp+=" && tobi ";

    cout<<"Début de tobi"<<endl;
    vector<bool> interOkA, interOkB;
    int i, j, diffX, diffY;
    interOkA.resize(listeInterA->size());
    interOkB.resize(listeInterB->size());

    for (i=0; i<(int)listeInterA->size(); i++)
        interOkA[i]=false;

    for (j=0; j<(int)listeInterB->size(); j++)
        interOkB[j]=false;

    cout<<"tobi : listeInterB : "<<endl;
    afficherVecteurInt(listeInterB);

    for (i=0; i<(int)listeInterA->size(); i++) {
        for (j=0; j<(int)listeInterB->size(); j++) {
            if (!interOkA[i] || !interOkB[j]) {
                diffX = abs(abscisse((*listeInterB)[j])-abscisse((*listeInterA)[i]));
                diffY = abs(ordonnee((*listeInterB)[j])-ordonnee((*listeInterA)[i]));
                if (((diffX == 2 && diffY == 0) || (diffX == 0 && diffY == 2)) && g->getIntersection((abscisse((*listeInterB)[j])+abscisse((*listeInterA)[i]))/2, (ordonnee((*listeInterB)[j])+ordonnee((*listeInterA)[i]))/2)->couleur() == VIDE) { // c'est un tobi
                    interOkA[i] = true;
                    interOkB[j] = true;
                    cout<<"Les intersections ("<<abscisse((*listeInterA)[i])<<";"<<ordonnee((*listeInterA)[i])<<") et ("<<abscisse((*listeInterB)[j])<<";"<<ordonnee((*listeInterB)[j])<<") forment un tobi et seront donc retenues"<<endl;
                }
            }
        }
    }

    for (i=interOkA.size()-1; i>=0; i--) {
        if (interOkA[i] == false)
            listeInterA->erase(listeInterA->begin()+i);
    }

    for (j=interOkB.size()-1; j>=0; j--) {
        if (interOkB[j] == false)
            listeInterB->erase(listeInterB->begin()+j);
    }

    cout<<"Fin de tobi"<<endl;
    return listeInterB->size()>0; // listeInterA->size() est donc également >0
}

bool regles::videAutour(vector<int> * listeIntersections, int distance) {
    traceTemp+=" && videAutour(";
    traceTemp+=(distance+48);
    traceTemp+=")";

    int i = 0, ligne, colonne;
    //int xinter, yinter;
    bool pierre;
    Intersection * inter;
    while (i < (int)listeIntersections->size()) {
        pierre = false;
        inter = getIntersection((*listeIntersections)[i]);
        // ligne = max(inter->getX() - distance, 0);
        ligne = inter->getX() - distance;
        // on parcourt les intersections alentours ŕ la recherche d'une pierre
        //while(ligne < min(inter->getX()+distance, g->getTaille()-1) and pierre == false)
        while (ligne < inter->getX()+distance+1 and pierre == false) {
            //colonne = max(inter->getY() - distance, 0);
            colonne = inter->getY() - distance;
            //while(colonne < min(inter->getY()+distance, g->getTaille()-1) and pierre == false)
            while (colonne < inter->getY()+distance+1 and pierre == false) {
                if (g->getIntersection(ligne, colonne)->couleur() == VIDE /* or (ligne == inter->getX() and colonne == inter->getY()) */ || ((colonne == inter->getY() - distance || colonne == inter->getY() + distance) &&  (ligne == inter->getX() - distance || ligne == inter->getX() + distance))) {
                    //cout<<"intersection "<<ligne<<" - "<<colonne<<"est safe pour la pierre"<<inter->getX()<<" - "<<inter->getY()<<endl;
                    colonne++;
                } else {
                    pierre = true;
                    //cout<<"inter->getY()+distance : "<<inter->getY()+distance<<" - g->getTaille()-1 : "<<g->getTaille()-1<<" - min(inter->getY()+distance, g->getTaille()-1) :"<<min(inter->getY()+distance, g->getTaille()-1)<<endl;
                    //cout<<"case "<<i<<" : La pierre en ("<<ligne<<", "<<colonne<<") fait que l'intersection numéro "<<(*listeIntersections)[i]<<" ("<<inter->getX()<<", "<<inter->getY()<<") n'a pas été retenue"<<endl;

                }
            }
            ligne++;
        }

        // une pierre a été trouvée, on retire l'intersection étudiée de la liste
        if (pierre == true)
            listeIntersections->erase(listeIntersections->begin() + i);
        else {
            i++;
            cout<<"case "<<i<<" : L'intersection numéro "<<(*listeIntersections)[i]<<" ("<<inter->getX()<<", "<<inter->getY()<<") ne comprend aucune pierre ŕ "<<distance<<" cases ŕ la ronde"<<endl;
        }
    }

    return listeIntersections->size() > 0;
}

bool regles::voisinDroitBlanc(vector<int> * listeInter) { // vire les pierres dont le voisin de droite n'est pas une pierre blanche
    traceTemp+=" && voisinDroitBlanc";

    cout<<"Début voisinDroitBlanc"<<endl;
    int i=0;
    Intersection * inter;
    while (i<(int)listeInter->size()) {
        cout<<"Début du while de voisinDroitBlanc : intersection : ("<<abscisse((*listeInter)[i])<<";"<<ordonnee((*listeInter)[i])<<")"<<endl;
        inter = g->getIntersection(abscisse((*listeInter)[i]), ordonnee((*listeInter)[i]))->getPierreDroite();
        if (inter == NULL)
            cout<<"inter a une valeur nulle";
        else {
            cout<<"inter vaut "<<inter<<endl;
            cout<<"inter : x = "<<inter->getX()<<" , y = "<<inter->getY()<<endl;
            cout<<"couleur de l'inter : "<<inter->couleur()<<endl;
        }
        if (inter!=NULL && inter->couleur() == BLANC) {
            cout<<"L'intersection a pour voisin de droite une pierre blanche et est donc conservée"<<endl;
            i++;
        } else
            listeInter->erase(listeInter->begin()+i);
    }
    cout<<"Fin voisinDroitBlanc"<<endl;
    return listeInter->size()>0;
}

bool regles::voisinDroitNoir(vector<int> * listeInter) { // vire les pierres dont le voisin de droite n'est pas une pierre noire
    traceTemp+=" && voisinDroitNoir";

    cout<<"Début voisinDroitNoir"<<endl;
    int i=0;
    Intersection * inter;
    while (i<(int)listeInter->size()) {
        inter = g->getIntersection(abscisse((*listeInter)[i]), ordonnee((*listeInter)[i]))->getPierreDroite();
        if (inter!=NULL && inter->couleur() == NOIR) {
            cout<<"L'intersection a pour voisin de droite une pierre noire et est donc conservée"<<endl;
            i++;
        } else
            listeInter->erase(listeInter->begin()+i);
    }
    cout<<"Fin voisinDroitNoir"<<endl;
    return listeInter->size()>0;
}

bool regles::voisinGaucheBlanc(vector<int> * listeInter) { // vire les pierres dont le voisin de gauche n'est pas une pierre blanche
    traceTemp+=" && voisinGaucheBlancs";

    cout<<"Début voisinGaucheBlanc"<<endl;
    if (g->getIntersection(2,14)->getPierreGauche()!=NULL)
        cout<<"Pierre ŕ gauche de (2;14) : ("<<g->getIntersection(2,14)->getPierreGauche()->getX()<<";"<<g->getIntersection(2,14)->getPierreGauche()->getY()<<")"<<endl;
    else
        cout<<"La pierre en (2;14) n'a pas de voisins de gauche"<<endl;
    int i=0;
    Intersection * inter;
    while (i<(int)listeInter->size()) {
        cout<<"Début du while de voisinGaucheBlanc : intersection : ("<<abscisse((*listeInter)[i])<<";"<<ordonnee((*listeInter)[i])<<")"<<endl;
        inter = g->getIntersection(abscisse((*listeInter)[i]), ordonnee((*listeInter)[i]))->getPierreGauche();
        if (inter == NULL)
            cout<<"inter a une valeur nulle"<<endl;
        else {
            cout<<"inter vaut "<<inter<<endl;
            cout<<"inter : abscisse:"<<inter->getX()<<" - ordonnée : "<<inter->getY()<<endl;
            cout<<"couleur de l'inter : "<<inter->couleur()<<endl;
        }
        if (inter!=NULL && inter->couleur() == BLANC) {
            cout<<"L'intersection a pour voisin de gauche une pierre blanche et est donc conservée"<<endl;
            i++;
        } else
            listeInter->erase(listeInter->begin()+i);
    }
    cout<<"Fin voisinGaucheBlanc : taille :"<<listeInter->size()<<endl;
    return listeInter->size()>0;
}

bool regles::voisinGaucheNoir(vector<int> * listeInter) { // vire les pierres dont le voisin de gauche n'est pas une pierre noire
    traceTemp+=" && voisinGaucheNoir";

    cout<<"Début voisinGaucheNoir"<<endl;
    int i=0;
    Intersection * inter;
    while (i<(int)listeInter->size()) {
        inter = g->getIntersection(abscisse((*listeInter)[i]), ordonnee((*listeInter)[i]))->getPierreGauche();
        if (inter!=NULL && inter->couleur() == NOIR) {
            cout<<"L'intersection a pour voisin de gauche une pierre noire et est donc conservée"<<endl;
            i++;
        } else
            listeInter->erase(listeInter->begin()+i);
    }
    cout<<"Fin voisinGaucheNoir"<<endl;
    return listeInter->size()>0;
}

int regles::nbLibBonus(int x, int y, Groupe * grp) {

    int nbLibertesBonus = 0;
    char couleur = grp->getCouleur();
    if (g->dansPlateau(x,y) && g->getIntersection(x,y)->getGroupe()  != grp ) { // si l'intersection est dans le goban et qu'elle n'appartient aps au groupe que l'onregarde.
        cout<<x<<" : "<<y<<" : "<<g->getIntersection(x,y)->couleur()<<endl;
        switch (g->getIntersection(x,y)->couleur()) { // selon la couleur de cette intersection
        case VIDE:
            nbLibertesBonus += 1;
            cout<<" + 1"<<endl;
            break;

        case NOIR:
            if (couleur == NOIR) {
                nbLibertesBonus += g->getIntersection(x,y)->getGroupe()->getNbLib() -1; // -1 car ce coup enlčve une liberté au groupe en question
                cout<<"nbLib="<<nbLibertesBonus<<endl;
            }
            break;

        case BLANC:
            if (couleur == BLANC) {
                nbLibertesBonus += g->getIntersection(x,y)->getGroupe()->getNbLib() -1; // -1 car ce coup enlčve une liberté au groupe en question
                cout<<"nbLib="<<nbLibertesBonus<<endl;
            }
            break;
        }
    }
    return nbLibertesBonus;
}


bool regles::intersectionAbs(Groupe * grp, int coord) {

    int i =0;
    while (i < g->getTaille() && ! grp->findIntersection(coord, i)) {
        i++;
    }
    return (i < g->getTaille());
}

bool regles::intersectionOrd(Groupe * grp, int coord) {
    int i =0;
    while (i < g->getTaille() && ! grp->findIntersection(i,coord)) {
        i++;
    }
    return (i < g->getTaille());
}

/*
void regles::transformer(){


}
*/

bool regles::jouer (void (*fct)(vector<vector<int> >,regles *, int), string nomFct, vector<vector<int> > arguments, int valeur) {
    cout<<"Bienvenue dans la fonction jouer, ici pour executer la magnifique fonction: "<<nomFct<<endl;
    *fichier<<traceTemp<<" -> jouer : "<<nomFct<<" avec le ratio " <<valeur <<" sur ";
    *fTrace<<sTrace<<" => "<<nomFct<<" avec le ratio " <<valeur <<" sur ";
    for (int i=0; i<(int) arguments[0].size(); i++) {
        *fichier<<"( ";
        *fTrace<<"( ";
        for (int j=0; j< (int)arguments.size(); j++) {
            *fichier<<arguments[j][i]<<", ";
            *fTrace<<arguments[j][i]<<", ";
        }
        *fichier<<") ";
        *fTrace<<") ";
    }

    //transformer(arguments);

        *fTrace<<endl;
    *fichier<<endl;
    //cout<<"JOUUUUUUUUEEEERRRRR  "<<arguments.size()<<" - "<<arguments[0]->size()<<endl;
    int i;
    ConcluPoids cp;
    //vérification que la conclusion n'a pas déja été obtenue avec la męme valeur
    for (i =0; i <(int) Conclusions.size(); i++) {
        if (( Conclusions[i].nomConclu== nomFct)&&(Conclusions[i].Poids==valeur)) {
            return false;   // break;
        }
    }
    //si non, on la rajoute aux conclusions
    if (i == (int)Conclusions.size()) {
        cp.Conclu=fct;
        cp.nomConclu=nomFct;
        cp.Poids=valeur;
//                for (int j = 0; j<arguments.size();j++){
//                    for (int k =0; k<arguments[j].size();j++){
        cp.args=arguments;
    }

    Conclusions.push_back(cp);

    //cout<<"CP: "<<cp.args.size()<<" - "<<cp.args[0]->size()<<endl;
    cout<<"PREexecuterConcl!!! arguments2: "<<Conclusions[i].args[0].size()<<endl;
    cout<<"PREexecuterConcl!!! arguments3: "<<Conclusions[i].args[1].size()<<endl;



    //cout<<"JOUUUUUUUUEEEERRRRR2222    "<<arguments.size()<<" - "<<arguments[0]->size()<<endl;
    //  fct(arguments);
    cout<<"Déja la fin de la magnifique fonction jouer, quel dommage!"<<endl;
    return true;
}

void regles::afficherPoids() {
    cout<<"**Tableau des Poids **"<<endl;
    cout<<"       0    1    2    3    4    5    6    7    8    9   10   11   12   13   14   15   16   17   18"<<endl;
    for (int i =0; i< (int)Poids.size(); i++) {
        if (i<10) cout<<i<<": ";
        else cout<<i<<":";
        for (int j =0;j<(int)Poi