/// <summary>
/// Gestion de la répartition des gains en fonction des différentes mains
/// </summary>
internal List <MainPoker> CalculerMainsGagnantes()
{
// Construction des mains
List <MainPoker> listeMains = new List <MainPoker>();
foreach (Joueur j in this.ListeJoueurs)
{
if (!j.Elimine)
{
var main = new MainPoker(j, this.Board);
main.DeterminerCombinaison();
listeMains.Add(main);
}
}
// On trie les mains
listeMains.Sort();
// On les trace
logServeur.Debug("Board : {0}, {1}, {2}, {3}, {4}", this.Board[0], this.Board[1], this.Board[2], this.Board[3], this.Board[4]);
logServeur.Debug("Liste des mains (du plus petit au plus grand):");
foreach (MainPoker main in listeMains)
{
logServeur.Debug(" Joueur : {0} ({2}, {3}), Combinaison : {1}", main.Proprietaire.Nom, main.ResultatMain.TypeCombinaison.ToString(), main.Proprietaire.Carte1, main.Proprietaire.Carte2);
logServeur.Debug(" Main : {0}, {1}, {2}, {3}, {4}", main.ResultatMain.MainGagnante[0], main.ResultatMain.MainGagnante[1], main.ResultatMain.MainGagnante[2], main.ResultatMain.MainGagnante[3], main.ResultatMain.MainGagnante[4]);
}
return(listeMains);
}
/// <summary>
/// Distribution des gains
/// </summary>
/// <param name="listeMains">Liste des mains des différents joueurs encore en lice : ordonnée de la plus mauvaise à la meilleure</param>
/// <param name="miseMax">La mise maximum</param>
/// <param name="premierAppel">Si vrai : on envoie en plus des messages au client car c'est le premier appel de la récursivité</param>
/// <returns>Le message d'information correspondant au résultat si premierAppel = true</returns>
internal MessageInfo DistribuerGains(List <MainPoker> listeMains, int miseMax, bool premierAppel)
{
logServeur.Debug("Distribution des gains : {0} mains. MiseMax = {1}. Premier appel = {2}", listeMains.Count, miseMax, premierAppel);
// Gestion des égalités
int nbGagnants = 1;
while (nbGagnants != listeMains.Count && listeMains[listeMains.Count - nbGagnants - 1].Equals(listeMains[listeMains.Count - 1]))
{
nbGagnants++;
}
MainPoker mainGagnante = listeMains[listeMains.Count - 1];
Joueur vainqueur = mainGagnante.Proprietaire;
List <Joueur> listeVainqueurs = new List <Joueur>();
int montantTotal = 0;
logServeur.Debug(" Nombre de gagnants : {0}", nbGagnants);
logServeur.Debug(" Mise totale du vainqueur : {0}", vainqueur.MiseTotale);
if (nbGagnants == 1)
{
if (premierAppel)
{
listeVainqueurs.Add(vainqueur);
}
// On commence par empocher le pot
if (vainqueur.MiseTotale == miseMax)
{
logServeur.Debug(" Pas de problème : celui qui a gagné c'est celui qui a misé le plus");
foreach (Joueur j in ListeJoueurs)
{
montantTotal += j.MiseTotale;
}
vainqueur.TapisJoueur += montantTotal;
}
else
{
logServeur.Debug(" Le vainqueur a misé moins que les autres : il faut redistribuer");
int miseTotaleVainqueur = vainqueur.MiseTotale;
bool continu = false;
foreach (MainPoker main in listeMains)
{
if (main.Proprietaire.MiseTotale > miseTotaleVainqueur)
{
continu = true;
montantTotal += miseTotaleVainqueur;
main.Proprietaire.MiseTotale -= miseTotaleVainqueur;
}
else
{
montantTotal += main.Proprietaire.MiseTotale;
main.Proprietaire.MiseTotale = 0;
}
}
vainqueur.TapisJoueur += montantTotal;
if (continu)
{
miseMax -= miseTotaleVainqueur;
// On retire les mains qui sont à zéro des gagnants, et on recommence
List <MainPoker> nouvelleListeMains = new List <MainPoker>();
foreach (MainPoker main in listeMains)
{
if (main.Proprietaire.MiseTotale != 0)
{
nouvelleListeMains.Add(main);
}
}
DistribuerGains(nouvelleListeMains, miseMax, false);
}
}
}
else
{
// Plusieurs gagnants : on boucle jusqu'à ne plus en avoir qu'un
int miseMini = int.MaxValue;
// On récupère la mise la plus petite effectuée par un gagnant
foreach (MainPoker main in listeMains)
{
if (mainGagnante.Equals(main))
{
miseMini = Math.Min(main.Proprietaire.MiseTotale, miseMini);
}
}
logServeur.Debug(" Mise mini : {0}", miseMini);
// On additionne les mises (avec cette mise comme max)
bool resteMise = false;
foreach (MainPoker main in listeMains)
{
if (main.Proprietaire.MiseTotale <= miseMini)
{
montantTotal += main.Proprietaire.MiseTotale;
main.Proprietaire.MiseTotale = 0;
}
else
{
resteMise = true;
montantTotal += miseMini;
main.Proprietaire.MiseTotale -= miseMini;
}
if (premierAppel && !main.Proprietaire.JeterCartes && mainGagnante.Equals(main))
{
listeVainqueurs.Add(main.Proprietaire);
}
}
// On partage le tout entre les gagnants et seulement les gagnants
foreach (MainPoker main in listeMains)
{
//TODO : montant total est il forcément un multiple de nbgagnants ?
if (mainGagnante.Equals(main))
{
main.Proprietaire.TapisJoueur += montantTotal / nbGagnants;
}
}
// Si la mise la plus petite était égale à la mise max --> Fini
// Sinon, on retire les mains qui sont à zéro des gagnants, et on recommence
if (resteMise)
{
List <MainPoker> nouvelleListeMains = new List <MainPoker>();
foreach (MainPoker main in listeMains)
{
if (main.Proprietaire.MiseTotale != 0)
{
nouvelleListeMains.Add(main);
}
}
DistribuerGains(nouvelleListeMains, miseMax, false);
}
}
if (premierAppel)
{
if (listeVainqueurs.Count == 1)
{
return(new MessageInfo(vainqueur, mainGagnante.ResultatMain, montantTotal));
}
else
{
return(new MessageInfo(listeVainqueurs, mainGagnante.ResultatMain, montantTotal));
}
}
else
{
return(null);
}
}
