public Carte DemarrerIA()
{
manager = GameObject.FindGameObjectWithTag("Manager");
jeu_IA = manager.GetComponent <GameManager>().jeuIA;
jeu_Humain = manager.GetComponent <GameManager>().jeuHumain;
defosse = manager.GetComponent <GameManager>().defosse;
nb_carte_pioche = manager.GetComponent <GameManager>().pioche.Count;
//defosse = manager.GetComponent
Joueur_humain = GameManager.J1_humain;
Joueur_IA = GameManager.J2_IA;
// Si c'est l'IA qui joue
if (GameManager.J1_humain_plays == false)
{
nb_cartes_joueur_contre = manager.GetComponent <GameManager>().jeuHumain.Count;
jeu_current_player = jeu_IA;
}
// Si c'est l'humain qui joue
else
{
nb_cartes_joueur_contre = manager.GetComponent <GameManager>().jeuIA.Count;
jeu_current_player = jeu_Humain;
}
Carte tmp;
//Debug.Log(jeuEnnemi);
//Debug.Log(defosse);
//Debug.Log(J1.PlisLumiere.Count);
//Debug.Log(J2.PlisPlante.Count);
// J1, c'est l'humain
// J2, c'est l'IA
if (MenuManager.typeJeu == 1)
{ //jeu normal, il n'y a qu'une seule IA
switch (MenuManager.niveauIAnormal)
{
case 1:
last_IA_use = IA_v.version_1;
tmp = IA_new(IA_v.version_1);
break;
case 2:
last_IA_use = IA_v.version_2;
tmp = IA_new(IA_v.version_2);
break;
case 3:
last_IA_use = IA_v.version_3;
tmp = IA_new(IA_v.version_3);
break;
case 4:
last_IA_use = IA_v.version_4;
tmp = IA_new(IA_v.version_4);
break;
default:
last_IA_use = IA_v.version_3;
tmp = IA_new(IA_v.version_3);
break;
}
if (jeu_IA.Contains(tmp) == false)
{
Debug.LogError("L'IA m'a donné une carte qui n'était pas à l'IA");
}
return(tmp);
}
else
{
if (GameManager.J1_humain_plays == true)
{
switch (MenuManager.niveauIA1)
{
case 1:
tmp = IA_new(IA_v.version_1);
break;
case 2:
tmp = IA_new(IA_v.version_2);
break;
case 3:
tmp = IA_new(IA_v.version_3);
break;
case 4:
tmp = IA_new(IA_v.version_4);
break;
default:
tmp = IA_new(IA_v.version_3);
break;
}
if (jeu_Humain.Contains(tmp) == false)
{
Debug.LogError("L'IA m'a donné une carte qui n'appartient pas à J1_humain");
}
return(tmp);
}
else
{
switch (MenuManager.niveauIA2)
{
case 1:
tmp = IA_new(IA_v.version_1);
break;
case 2:
tmp = IA_new(IA_v.version_2);
break;
case 3:
tmp = IA_new(IA_v.version_3);
break;
case 4:
tmp = IA_new(IA_v.version_4);
break;
default:
tmp = IA_new(IA_v.version_3);
break;
}
if (jeu_IA.Contains(tmp) == false)
{
Debug.LogError("L'IA m'a donné une carte qui n'appartient pas à J2_IA");
}
return(tmp);
}
}
}
public Carte IA_new(IA_v version)
{
List <Carte> jeu_player;
Joueur moi;
Joueur ennemie;
IA.carte_defosse = null;
if (GameManager.J1_humain_plays == true)
{
jeu_player = jeu_Humain;
moi = Joueur_humain;
ennemie = Joueur_IA;
}
else
{
jeu_player = jeu_IA;
moi = Joueur_IA;
ennemie = Joueur_humain;
}
if (GameManager.J1_humain_plays == true)
{
Debug.LogWarning("IA pour humain");
}
else
{
Debug.LogWarning("IA pour IA");
}
List <Combinaisons> combinaisons;
List <Carte_IA> proba_par_carte;
List <Carte_IA_v3> proba_par_paire;
List <Carte_IA_v4> proba_par_paire_avec_defense;
if (version == IA_v.version_0)
{
return(IA_V0_aleatoire());
}
combinaisons = IA_V1_load_probabilites(moi, ennemie);
if (version == IA_v.version_1)
{
return(IA_V1_choose_best_carte(combinaisons));
}
proba_par_carte = IA_V2_load_proba_par_carte(combinaisons);
if (version == IA_v.version_2)
{
return(IA_V2_choose_best_card(proba_par_carte));
}
proba_par_paire = IA_V3_load_paires(proba_par_carte);
if (version == IA_v.version_3)
{
if (proba_par_paire.Count > 0)
{
return(IA_V3_choose_best_card_to_play(proba_par_paire));
}
// Si jamais il n'y a aucune combinaison qui marche, on prend juste la carte qui a le plus faible poids, c'est à dire on applique l'IA V2
else
{
return(IA_V2_choose_best_card(proba_par_carte));
}
}
proba_par_paire_avec_defense = IA_V4_load_paires(proba_par_paire);
if (version == IA_v.version_4)
{
if (proba_par_paire_avec_defense.Count > 0)
{
return(IA_V4_choose_best_card_to_play(proba_par_paire_avec_defense));
}
else
{
return(IA_V4_defosse_card(proba_par_carte));
}
}
// Juste pour faire taire le compilo mais normalement, on ne devrait jamais sortir de la fonction ici
return(jeu_player[0]);
}
