/Expertbot/regles/regles.cpp
C++ | 1843 lines | 1328 code | 235 blank | 280 comment | 353 complexity | 341742a9d5ae18d035bffbe7d4f1bd72 MD5 | raw file
Large files files are truncated, but you can click here to view the full file
- #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();
- …
Large files files are truncated, but you can click here to view the full file