Beispiel #1
0
        /// <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);
        }
Beispiel #2
0
        /// <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);
            }
        }