Beispiel #1
0
        /// <summary>
        /// fonction qui force le pairing sans faire attention au classement
        /// </summary>
        /// <param name="players">liste des joueur qui doivent avoir un paring</param>
        /// <param name="playerOpponentList">dictionnaire de list d'adversaire déjà rencontré par chaque adversaire</param>
        /// <param name="pairing">liste de pairing actuelle</param>
        /// <param name="retour">variable qui contiendra le pairing final</param>
        /// <returns>signal si le pairing est complete</returns>
        private static bool ForcePairing(List <int> players, Dictionary <int, List <int> > playerOpponentList, List <PairID> pairing, out List <PairID> retour)
        {
            List <int> NoPairedPlayer = players.Where(pl => !pairing.Exists(pa => pa.ID1 == pl || pa.ID2 == pl)).ToList();//crée la liste de tout les joueur non pairé

            retour = pairing;

            List <int> tempOutReportedPlayer = new();

            tempOutReportedPlayer.AddRange(NoPairedPlayer);                                                     //crée un doublons de la list des joueur reporté
            foreach (var Player in tempOutReportedPlayer)                                                       //pour tout les joueur reporté
            {
                if (NoPairedPlayer.Contains(Player))                                                            //on verifie que le joueur est encore dans les joueur reporté
                {
                    foreach (var pair in retour)                                                                //pour chaque pairing dejà fait
                    {
                        if (!playerOpponentList[Player].Contains(pair.ID1))                                     //on regard si le playerone du pairing n'est pas dans la liste des adversaire déjà rencontré
                        {
                            var ListNewOpponent = NoPairedPlayer.Except(playerOpponentList[pair.ID2]).ToList(); //on crée une liste d'advaisaire potentielle sur base des joueur reporté qui serait ne serait pas dans la liste des adversaire du playertwo de la pair
                            ListNewOpponent.Remove(Player);                                                     //on retire le joueur que l'on tente de pairé de la liste des potentille nouveau adversaire du playertwo (vu que le jouer va être apparaillé au playerone)
                            if (ListNewOpponent.Any())                                                          //on regard si il reste un adversaire potentielle
                            {
                                var rng         = new Random();
                                var NewOpponent = ListNewOpponent.ElementAt(rng.Next(0, ListNewOpponent.Count)); //on choisie alléatoirement un adversaire parmi les adversaire potentielle

                                var pairPlayer1 = new PairID                                                     //on crée une nouveelle pair
                                {
                                    ID1 = pair.ID2,
                                    ID2 = NewOpponent        //on pair le player 2 avec l'adversaire choisie aléatoirement
                                };
                                retour.Add(pairPlayer1);     //on joute la nouvelle pair
                                var pairPlayer2 = new PairID //on crée une nouveelle pair
                                {
                                    ID1 = pair.ID1,
                                    ID2 = Player                    //on pair le player1 avec le joueur que l'on tant de pairé
                                };
                                retour.Add(pairPlayer2);            //on joute la nouvelle pair

                                retour.Remove(pair);                //on supprime l'ancienne pair
                                NoPairedPlayer.Remove(NewOpponent); //on retire l'adversaire choisie au hazard des joueur reporté
                                NoPairedPlayer.Remove(Player);      //on retire joueur des joueur reporté

                                break;
                            }
                        }
                    }
                }
            }

            return(!NoPairedPlayer.Any());
        }
Beispiel #2
0
        /// <summary>
        /// Fonction qui fait le paring des joueur qui ce strouve dans un même regroupement fait sur base du classement
        ///
        /// il peu y avoir des joueur d'un autre groupe
        /// </summary>
        /// <param name="Players">liste des joueur a pairé</param>
        /// <param name="PlayerOpponentList">dictonnaire des adversaire pour chaque joueur</param>
        /// <param name="OutReportedPlayer"> paramttre qui va listé les joueur qui sont reporté car impossible de pairé dans ce groupe</param>
        /// <param name="InReportedPlayer">liste de joueur qui sont rajouté a ce groupe car il n'ont pas pu être pairé dans celui d'avant</param>
        /// <returns>liste de pairing de joueur effectué pour ce groupe</returns>
        private static List <PairID> PairingInGroup(List <int> Players, Dictionary <int, List <int> > PlayerOpponentList, out List <int> OutReportedPlayer, List <int> InReportedPlayer = null)
        {
            List <PairID> retour = new();         // crée la variable qui se verra atrivué la liste de pairing qui doit être retourné.

            OutReportedPlayer = new List <int>(); //initilaization du paramtre out OutreportedPlayer
            OutReportedPlayer.Clear();            // on s'assure que le parametre out est bien vide

            List <int> AllRemainingPlayer = new();

            AllRemainingPlayer.Clear();
            AllRemainingPlayer.AddRange(Players);

            if (InReportedPlayer != null && InReportedPlayer.Count > 0) //on verfie si il y a des joueur reporté
            {
                AllRemainingPlayer.AddRange(InReportedPlayer);          // on ajoute les joueur reporté a la liste des joueur restant a appareillé

                foreach (var Player in InReportedPlayer)                //pour chaque joueur reporté a appareillé
                {
                    if (AllRemainingPlayer.Contains(Player))            //on verifie que le joueur est toujours dans la liste des joueur a appareillé
                    {
                        if (PairAPlayer(Player, PlayerOpponentList, AllRemainingPlayer, out var pairPlayer)
                            ) // on essaye de l'appareillé
                        {
                            // si on réussie on affect l'appareillement
                            AllRemainingPlayer.Remove(pairPlayer.ID1);
                            AllRemainingPlayer.Remove(pairPlayer.ID2);

                            retour.Add(pairPlayer);
                        }
                        else //si on ne reussie pas on rajoute le joueur ala liste des joueur a reporté
                        {
                            OutReportedPlayer.Add(Player);
                        }
                    }
                }
            }

            foreach (var player in Players)              //pour chaque joueur a appareillé
            {
                if (AllRemainingPlayer.Contains(player)) //on verifie que le joueur est toujours dans la liste des joueur a appareillé
                {
                    if (PairAPlayer(player, PlayerOpponentList, AllRemainingPlayer, out var pairPlayer)
                        ) // on essaye de l'appareillé
                    {
                        // si on réussie on affect l'appareillement et retrie les joueuer appareillé
                        AllRemainingPlayer.Remove(pairPlayer.ID1);
                        AllRemainingPlayer.Remove(pairPlayer.ID2);

                        retour.Add(pairPlayer);
                    }
                    else //si on ne reussie pas on rajoute le joueur ala liste des joueur a reporté
                    {
                        OutReportedPlayer.Add(player);
                    }
                }
            }

            if (OutReportedPlayer.Count > 1)// si il y a plus d'un joueur reporté on verifie que en faisant des permutation on ne peu pas les appareillé quand même
            {
                List <int> tempOutReportedPlayer = new();
                tempOutReportedPlayer.AddRange(OutReportedPlayer);                                                     //crée un doublons de la list des joueur reporté
                foreach (var Player in tempOutReportedPlayer)                                                          //pour tout les joueur reporté
                {
                    if (OutReportedPlayer.Contains(Player))                                                            //on verifie que le joueur est encore dans les joueur reporté
                    {
                        foreach (var pair in retour)                                                                   //pour chaque pairing dejà fait
                        {
                            if (!PlayerOpponentList[Player].Contains(pair.ID1))                                        //on regard si le playerone du pairing n'est pas dans la liste des adversaire déjà rencontré
                            {
                                var ListNewOpponent = OutReportedPlayer.Except(PlayerOpponentList[pair.ID2]).ToList(); //on crée une liste d'advaisaire potentielle sur base des joueur reporté qui serait ne serait pas dans la liste des adversaire du playertwo de la pair
                                ListNewOpponent.Remove(Player);                                                        //on retire le joueur que l'on tente de pairé de la liste des potentille nouveau adversaire du playertwo (vu que le jouer va être apparaillé au playerone)
                                if (ListNewOpponent.Any())                                                             //on regard si il reste un adversaire potentielle
                                {
                                    var rng         = new Random();
                                    var NewOpponent = ListNewOpponent.ElementAt(rng.Next(0, ListNewOpponent.Count)); //on choisie alléatoirement un adversaire parmi les adversaire potentielle

                                    var pairPlayer1 = new PairID                                                     //on crée une nouveelle pair
                                    {
                                        ID1 = pair.ID2,
                                        ID2 = NewOpponent        //on pair le player 2 avec l'adversaire choisie aléatoirement
                                    };
                                    retour.Add(pairPlayer1);     //on joute la nouvelle pair
                                    var pairPlayer2 = new PairID //on crée une nouveelle pair
                                    {
                                        ID1 = pair.ID1,
                                        ID2 = Player                       //on pair le player1 avec le joueur que l'on tant de pairé
                                    };
                                    retour.Add(pairPlayer2);               //on joute la nouvelle pair

                                    retour.Remove(pair);                   //on supprime l'ancienne pair
                                    OutReportedPlayer.Remove(NewOpponent); //on retire l'adversaire choisie au hazard des joueur reporté
                                    OutReportedPlayer.Remove(Player);      //on retire joueur des joueur reporté

                                    break;
                                }
                            }
                        }
                    }
                }
            }


            return(retour);
        }