124a125,131
> case_type typeCaseZone(int iGraphe, int iZone) {
>     if(iGraphe == MOI_GRAPHE)
>         return type_case(zones[iGraphe][iZone][0], moi());
>     else
>         return type_case(zones[iGraphe][iZone][0], adversaire());
> }
> 
181a189,218
> int nbCasesZone(int iGraphe, int iZone) {
>     return zones[iGraphe][iZone].size();
> }
> 
> int nbCasesVoisins(int iGraphe, int iZone) {
>     int ret = 0;
>     for(int iVoisin : voisins[iGraphe][iZone])
>         ret += nbCasesZone(iGraphe, iVoisin);
>     return ret;
> }
> 
> int nbCatalysesPlusGrosseZone(int iGraphe) {
>     vector<pair<int, int> > tailleEtId;
>     for(int iZone = 0; iZone < (int)zones[iGraphe].size(); iZone++) {
>         if(propriete_case_type(typeCaseZone(iGraphe, iZone)) == TRANSMUTABLE_OR)
>             tailleEtId.push_back(pair<int, int> (zones[iGraphe][iZone].size(), iZone));
>     }
>     sort(tailleEtId.begin(), tailleEtId.end(), greater<pair<int, int> > ());
>     return nbCasesVoisins(iGraphe, tailleEtId[0].second);
> }
> 
> int nbCasesType(case_type typeCase, int moiOuAdvLib) {
>     int ret = 0;
>     for(int lig = 0; lig < TAILLE_ETABLI; lig++)
>         for(int col = 0; col < TAILLE_ETABLI; col++)
>             if(type_case({lig, col}, moiOuAdvLib) == typeCase)
>                 ret++;
>     return ret;
> }
> 
197c234,235
<     for(vector<position> zone : zones[MOI_GRAPHE]) {
---
>     for(int iZone = 0; iZone < (int)zones[MOI_GRAPHE].size(); iZone++) {
>         vector<position> &zone = zones[MOI_GRAPHE][iZone];
199c237
<         if(propriete_case(arbitraire, moi()) == TRANSMUTABLE_CATALYSEUR && zone.size() >= 4) {
---
>         if(propriete_case(arbitraire, moi()) == TRANSMUTABLE_CATALYSEUR && zone.size() >= 3 && nbCatalysesPlusGrosseZone(MOI_GRAPHE) >= quantite_transmutation_catalyseur(zone.size())) {
200a239
>             cout << "[" << tour_actuel() << "] Transmutation case (" << arbitraire.ligne << "," << arbitraire.colonne << ") car catalyseur utile\n";
225c264,265
<         vector<pair<int, int>> nbParType(NB_TYPE_CASES, pair<int, int> (0,0));
---
>         /// Changement de stratégie planifié : si possible, un métal (pour essayer de m'en garantir un) et le métal vil le moins présent (oui !)
>         vector<pair<int, int>> nbParType(NB_TYPE_CASES, pair<int, int> (0,0)); /// La pair contient le type puis sa présence
227a268
> 
229d269
<         {
231d270
<             {
233c272,280
<             }
---
> 
>         /// Ah oui, il y a la règle. 2 cas:
>         /// - Deux métaux de même propriété. Le cas est vite résolu : le moins présent chez l'adversaire, à égalité le plus présent chez nous.
>         /// - Un métal normal, un métal vil. On lui donne le métal normal pour nous en assurer un.
>         bool memePropriete = propriete_case_type(aPlacer.element1) == propriete_case_type(aPlacer.element2);
>         bool deuxVils = false;
>         if(memePropriete && propriete_case_type(aPlacer.element1) == TRANSMUTABLE_CATALYSEUR) {
>             aDonner = aPlacer;
>             deuxVils = true;
235,238c282,292
<         if(nbParType[typetoint(aPlacer.element1)].second < nbParType[typetoint(aPlacer.element2)].second)
<             aDonner.element1 = aPlacer.element1;
<         else
<             aDonner.element1 = aPlacer.element2;
---
>         else {
>             if(propriete_case_type(aPlacer.element1) == TRANSMUTABLE_OR)
>                 aDonner.element1 = aPlacer.element1;
>             else
>                 aDonner.element1 = aPlacer.element2;
>         }
>         //if(nbParType[typetoint(aPlacer.element1)].second < nbParType[typetoint(aPlacer.element2)].second)
>         //    aDonner.element1 = aPlacer.element1;
>         //else
>         //    aDonner.element1 = aPlacer.element2;
>         //bool estVil = propriete_case_type(aDonner.element1) == TRANSMUTABLE_CATALYSEUR;
240,243c294,300
<         sort(nbParType.begin(), nbParType.end(), compareTypePresence);
<         for(pair<int, int> typ : nbParType)
<         {
<             if(aDonner.element1 != inttotype(typ.first) && aDonner.element2 != inttotype(typ.first))
---
>         /// Cas de l'élément 2, deux cas :
>         /// - Le métal choisi en 1er est normal. On lui donne un vil ?
>         /// - Le métal choisi est vil. Vaut mieux s'assurer une chance d'avoir un normal.
>         /// - Idée : si on recoit deux métaux vils, surtout répondre par la même !
>         if(!deuxVils) {
>             sort(nbParType.begin(), nbParType.end(), compareTypePresence);
>             for(pair<int, int> typ : nbParType)
245,246c302,307
<                 aDonner.element2 = inttotype(typ.first);
<                 break;
---
>                 if(propriete_case_type(inttotype(typ.first)) == TRANSMUTABLE_CATALYSEUR)
>                 //if(aDonner.element1 != inttotype(typ.first) && aDonner.element2 != inttotype(typ.first))
>                 {
>                     aDonner.element2 = inttotype(typ.first);
>                     break;
>                 }
252c313
<     //consommerMetauxVils();
---
>     consommerMetauxVils();
275a337,345
>             if(
>                     (possibilitesReglage.size() == 1 && propriete_case(possibilitesReglage[0], moi()) == TRANSMUTABLE_CATALYSEUR)
>                     //|| (possibilitesReglage.size() == 2 && propriete_case(possibilitesReglage[0], moi()) == TRANSMUTABLE_OR && taille_region(possibilitesReglage[0], moi()) == 2)
>                 )
>             {
>                 transmuter(possibilitesReglage[0]);
>                 cout << "[" << tour_actuel() << "] Transmutation case (" << possibilitesReglage[0].ligne << "," << possibilitesReglage[0].colonne << " car catalyseur isolé gênant\n";
>                 possibilitesReglage.clear();
>             }
284c354
<                     for(int dlig = -1; dlig <= 1; dlig++)
---
>                     for(int dlig = -2; dlig <= 2; dlig++)
286c356
<                         for(int dcol = -1; dcol <= 1; dcol++)
---
>                         for(int dcol = -2; dcol <= 2; dcol++)
302c372
<                 sort(scoresPotentiels.begin(), scoresPotentiels.end(), compareSizePosition2);
---
>                 sort(scoresPotentiels.begin(), scoresPotentiels.end(), compareSizePosition3);
305a376
>                     cout << "[" << tour_actuel() << "] Transmutation case (" << positionPotentielle.second.ligne << "," << positionPotentielle.second.colonne << ") pour libérer de la place\n";
336,337c407,415
<             if(aPlacer.element1 != aPlacer.element2)
<                 tailleTotale += taille_region(possibilite.pos2, moi());
---
>             if(propriete_case(possibilite.pos1, moi()) == TRANSMUTABLE_OR)
>                 tailleTotale *= 2;
>             if(aPlacer.element1 != aPlacer.element2) {
>                 /*tailleTotale += */
>                 int taille2 = taille_region(possibilite.pos2, moi());
>                 if(propriete_case(possibilite.pos2, moi()) == TRANSMUTABLE_OR)
>                     taille2 *= 2;
>                 tailleTotale += taille2;
>             }
