/// <summary>
/// Ajouter une pièce (s'il y en a déjà de son type, on incrémente le nombre de pièces, sinon on l'ajouter à la liste)
/// </summary>
/// <param name="piece">La pièce à ajouter</param>
public void AjouterPiece(Piece piece)
{
bool bTrouve = false;
foreach (PieceCapturee p in PiecesCapturees)
{
if (p.Piece.GetType() == piece.GetType())
{
p.Incrementer();
bTrouve = true;
}
}
if (!bTrouve)
{
PiecesCapturees.Add(new PieceCapturee(piece, StpParent));
}
}
/// <summary>
/// Calcule le nombre de pièces d'un type (pour une couleur) présentes dans la grille
/// </summary>
/// <param name="typePiece">Le type de pièce</param>
/// <param name="couleur">La couleur des pièce</param>
/// <returns>Le nombre de pièces</returns>
public int CalculerNombrePieces(Type typePiece, Couleur couleur)
{
int nbPieces = 0;
for (int x = 0; x < TAILLE_GRILLE_JEU; x++)
{
for (int y = 0; y < TAILLE_GRILLE_JEU; y++)
{
Piece piece = ObtenirPiece(new Coordonnee(x, y));
if (piece != null && piece.EstDeCouleur(couleur) && piece.GetType() == typePiece)
{
nbPieces++;
}
}
}
return(nbPieces);
}
/// <summary>
/// Calcule la cote du coup
/// </summary>
public void CalculerCote()
{
if (PieceCible != null)
{
if (PieceCible.EstVisible) // Si la cible est visible, on la classe selon le poid de la pièce,
{ // positif si on gagne et négatif si on perd
if (PieceAttaquant.GetType() == PieceCible.GetType())
{
Cote = 0;
}
else
{
if (DeterminerSiGagne(PieceAttaquant, PieceCible))
{
Cote = LIST_IMPORTANCE_PIECES[PieceCible.GetType()];
}
else
{
Cote = -LIST_IMPORTANCE_PIECES[PieceAttaquant.GetType()];
}
}
}
else // Si elle est invisible, on calcule la probabilité que ce soit de chaque type
{
int nombrePieces = Jeu.CalculerNombrePieces(CouleurIA);
List <Tuple <Type, double> > probabilites = new List <Tuple <Type, double> >
{
new Tuple <Type, double> (
typeof(Marechal),
(2 * Jeu.CalculerNombrePieces(typeof(Marechal), CouleurIA) - 1) / (double)nombrePieces
),
new Tuple <Type, double> (
typeof(General),
(2 * Jeu.CalculerNombrePieces(typeof(General), CouleurIA) - 1) / (double)nombrePieces
),
new Tuple <Type, double> (
typeof(Colonel),
(2 * Jeu.CalculerNombrePieces(typeof(Colonel), CouleurIA) - 2) / (double)nombrePieces
),
new Tuple <Type, double> (
typeof(Commandant),
(2 * Jeu.CalculerNombrePieces(typeof(Commandant), CouleurIA) - 3) / (double)nombrePieces
),
new Tuple <Type, double> (
typeof(Capitaine),
(2 * Jeu.CalculerNombrePieces(typeof(Capitaine), CouleurIA) - 4) / (double)nombrePieces
),
new Tuple <Type, double> (
typeof(Lieutenant),
(2 * Jeu.CalculerNombrePieces(typeof(Lieutenant), CouleurIA) - 4) / (double)nombrePieces
),
new Tuple <Type, double> (
typeof(Sergent),
(2 * Jeu.CalculerNombrePieces(typeof(Sergent), CouleurIA) - 4) / (double)nombrePieces
),
new Tuple <Type, double> (
typeof(Demineur),
(2 * Jeu.CalculerNombrePieces(typeof(Demineur), CouleurIA) - 5) / (double)nombrePieces
),
new Tuple <Type, double> (
typeof(Eclaireur),
(2 * Jeu.CalculerNombrePieces(typeof(Eclaireur), CouleurIA) - 8) / (double)nombrePieces
),
new Tuple <Type, double> (
typeof(Espion),
(2 * Jeu.CalculerNombrePieces(typeof(Espion), CouleurIA) - 1) / (double)nombrePieces
),
new Tuple <Type, double> (
typeof(Drapeau),
(2 * Jeu.CalculerNombrePieces(typeof(Drapeau), CouleurIA) - 1) / (double)nombrePieces
),
new Tuple <Type, double> (
typeof(Bombe),
(2 * Jeu.CalculerNombrePieces(typeof(Bombe), CouleurIA) - 6) / (double)nombrePieces
)
};
// On classe les résultats en ordre décroissant
probabilites.Sort((a, b) => { return((int)((b.Item2 - a.Item2) * 100)); });
List <Tuple <Type, double> > meilleursProbabilites = new List <Tuple <Type, double> >();
bool bEstPareil = true;
double dScore = probabilites[0].Item2;
for (int i = 0; i < probabilites.Count && bEstPareil; i++)
{
if (probabilites[i].Item2 != dScore)
{
bEstPareil = false;
}
else
{
meilleursProbabilites.Add(probabilites[i]);
}
}
// On choisi une pièce qui a le résultat le plus grand
Random rnd = new Random(DateTime.Now.Millisecond);
Type typePiece = meilleursProbabilites[rnd.Next(meilleursProbabilites.Count)].Item1;
Piece pieceCibleTemporaire = (Piece)Activator.CreateInstance(typePiece, new object[] { CouleurIA });
// Et on applique la logique de cote avec le candidat possible
if (PieceAttaquant.GetType() == pieceCibleTemporaire.GetType())
{
Cote = 0;
}
else
{
if (DeterminerSiGagne(PieceAttaquant, pieceCibleTemporaire))
{
Cote = LIST_IMPORTANCE_PIECES[pieceCibleTemporaire.GetType()];
}
else
{
Cote = -LIST_IMPORTANCE_PIECES[PieceAttaquant.GetType()];
}
}
}
}
}
