// Dans cette partie de l'IA v4, on ne va plus réfléchir que pour nous mais aussi pour l'adversaire.
// Ainsi, on va essayer de défendre
private List <Carte_IA_v4> IA_V4_load_paires(List <Carte_IA_v3> proba_par_paire)
{
List <Carte_IA_v4> toRet = new List <Carte_IA_v4>();
List <Carte_IA> proba_par_carte_ennemie;
if (GameManager.J1_humain_plays == true)
{
proba_par_carte_ennemie = IA_V2_load_proba_par_carte(IA_V1_load_probabilites(GameManager.J2_IA, GameManager.J1_humain));
}
else
{
proba_par_carte_ennemie = IA_V2_load_proba_par_carte(IA_V1_load_probabilites(GameManager.J1_humain, GameManager.J2_IA));
}
foreach (Carte_IA_v3 paire in proba_par_paire)
{
double val_main_ennemie;
double val_defosse_ennemie;
Carte_IA_v4 tmp;
int tmp1;
int tmp2;
// Ici, on trouvera forcément une occurence de la carte car si je l'ai ou que la défosse l'a, l'adversaire ne l'a pas.
tmp1 = Carte_IA.find_index_of(paire.main.carte, proba_par_carte_ennemie);
tmp2 = Carte_IA.find_index_of(paire.defosse.carte, proba_par_carte_ennemie);
val_main_ennemie = proba_par_carte_ennemie[tmp1].valeur;
val_defosse_ennemie = proba_par_carte_ennemie[tmp2].valeur;
tmp = new Carte_IA_v4(paire, val_main_ennemie, val_defosse_ennemie);
toRet.Add(tmp);
}
return(toRet);
}
public Carte_IA_v4(Carte_IA_v3 paire, double val_adverse_main, double val_adverse_defosse)
{
this.main = paire.main;
this.defosse = paire.defosse;
//this.val_pour_adv_carte_main = val_adverse_main;
this.val_pour_adv_carte_defosse = val_adverse_defosse;
}
public Carte_IA_v3(Carte_IA jeu, Carte_IA defosse)
{
this.main = jeu;
this.defosse = defosse;
if (this.defosse != null)
{
this.val = jeu.valeur + defosse.valeur;
}
else
{
this.val = -jeu.valeur;
}
}
private Carte IA_V4_defosse_card(List <Carte_IA> proba_par_carte)
{
List <Carte_IA> main = new List <Carte_IA>();
List <Carte_IA> proba_par_carte_ennemie;
if (GameManager.J1_humain_plays == true)
{
proba_par_carte_ennemie = IA_V2_load_proba_par_carte(IA_V1_load_probabilites(GameManager.J2_IA, GameManager.J1_humain));
}
else
{
proba_par_carte_ennemie = IA_V2_load_proba_par_carte(IA_V1_load_probabilites(GameManager.J1_humain, GameManager.J2_IA));
}
foreach (Carte carte in this.jeu_current_player)
{
double val;
int index_carte_mes_probas;
int index_carte_probas_ennemie;
index_carte_mes_probas = Carte_IA.find_index_of(carte, proba_par_carte);
index_carte_probas_ennemie = Carte_IA.find_index_of(carte, proba_par_carte_ennemie);
val = 0.0 - proba_par_carte[index_carte_mes_probas].valeur - (proba_par_carte_ennemie[index_carte_probas_ennemie].valeur / 2.0);
main.Add(new Carte_IA(carte, val));
}
main.Sort(delegate(Carte_IA a, Carte_IA b)
{
double score_a = a.valeur;
double score_b = b.valeur;
if (score_a > score_b)
{
return(-1);
}
else
{
return(1);
}
});
return(main[0].carte);
}
// On ne va maintenant plus résonner sur une carte mais sur 2 cartes
// Pour chacune des cartes, on va regarder avec quelle(s) carte(s) elle peut matcher et on va stocker tout ça...
private List <Carte_IA_v3> IA_V3_load_paires(List <Carte_IA> proba_par_carte)
{
List <Carte_IA_v3> paires = new List <Carte_IA_v3>();
List <Carte> jeu_player;
Carte tmp;
if (GameManager.J1_humain_plays == true)
{
jeu_player = jeu_Humain;
}
else
{
jeu_player = jeu_IA;
}
foreach (Carte carte in jeu_player)
{
List <Carte> tmp_list_defosse = new List <Carte>(defosse);
int i = 0;
// Si ça peut matcher avec plusieurs cartes de la défosse il faut relancer la detection pour toutes les trouver
do
{
tmp = carte.can_match_with(tmp_list_defosse);
if (tmp != null)
{
Carte_IA tmp_joueur;
Carte_IA tmp_defosse;
tmp_joueur = proba_par_carte[Carte_IA.find_index_of(carte, proba_par_carte)];
tmp_defosse = proba_par_carte[Carte_IA.find_index_of(tmp, proba_par_carte)];
paires.Add(new Carte_IA_v3(tmp_joueur, tmp_defosse));
}
tmp_list_defosse.Remove(tmp);
i++;
if (i == 4) // Quand y'a un pli 3 choix, on passe une 4ème fois dans la boucle pour recevoir le null
{
Debug.Log("L'IA peut faire un pli 3 choix. Pour l'instant, j'ai la flemme de programmer cette exception donc tant pis, l'IA va faire de la merde");
}
} while (tmp != null);
}
return(paires);
}
