public static void GenerateNextPairRound(TournamentDbContext _context)
        {
            int lastRound = GetLastRoundNo(_context);
            List <RoundMatchup> roundMatchups = _context.RoundMatchups.Include(r => r.PlayerOne).Include(r => r.PlayerTwo).Where(r => r.RoundNo == lastRound).ToList();
            List <PlayerPair>   playerPairs   = new List <PlayerPair>();

            foreach (RoundMatchup roundMatchup in roundMatchups)
            {
                PlayerPair pair = new PlayerPair()
                {
                    First  = roundMatchup.PlayerOne,
                    Second = roundMatchup.PlayerTwo
                };
                playerPairs.Add(pair);
            }

            //List<int> AllocatedTables = new List<int>(GetnoOfTables());
            int secondaryIndex = 0;
            int i = 0;

            while (i < playerPairs.Count)
            {
                //Skip this player if they are already allocated an opponent
                if (playerPairs[i].CurrentOpponent == null)
                {
                    if (secondaryIndex == 0)
                    {
                        secondaryIndex = i + 1;
                    }
                    int s = 0;

                    for (s = secondaryIndex; s < playerPairs.Count; s++)
                    {
                        if (playerPairs[s].CurrentOpponent == null)
                        {
                            //Check if higher player has ever played lower player
                            var playerOneOpponents = PlayerActions.GetAllOpponents(playerPairs[i].First, _context);
                            var playerTwoOpponents = PlayerActions.GetAllOpponents(playerPairs[i].Second, _context);
                            var opponents          = playerOneOpponents.Union(playerTwoOpponents);
                            var hasPlayed          = false;
                            foreach (Player opponent in opponents)
                            {
                                if (playerPairs[s].First == opponent || playerPairs[s].Second == opponent)
                                {
                                    hasPlayed = true;
                                }
                            }
                            //If they have not played allocate them as opponents
                            if (hasPlayed == false)
                            {
                                playerPairs[i].CurrentOpponent = playerPairs[s];
                                playerPairs[s].CurrentOpponent = playerPairs[i];
                                secondaryIndex = 0;
                                break;
                            }

                            /**
                             * Following block is to deallocate the next lowest ranked allocated pair
                             **/
                            if (playerPairs.Where(p => p.CurrentOpponent == null).LastOrDefault() == playerPairs[s] && (playerPairs[i].CurrentOpponent == null))
                            //if (s == (players.Count - 1) && (players[i].CurrentOpponent == null))
                            {
                                if (i - 1 >= 0)
                                {
                                    //Set the lowestAllocatedPair to the highest ranked pair
                                    PlayerPair lowestAllocatedPair = playerPairs[0];
                                    //Iterate from the second highest ranked pair all the way to the pair ranked one higher than the player currently being matched
                                    for (int playerIndex = 1; playerIndex < i; playerIndex++)
                                    {
                                        //Assign the current player to the player being examined in the current iteration of the loop
                                        PlayerPair currentPair = playerPairs[playerIndex];

                                        //Check that the current player has an opponent (if not, skip to the next iteration of the loop)
                                        if (currentPair.CurrentOpponent != null)
                                        {
                                            //Proceed if the current player's opponent has a higher rank than the current player
                                            if (playerPairs.IndexOf(currentPair.CurrentOpponent) < playerPairs.IndexOf(currentPair))
                                            {
                                                if (playerPairs.IndexOf(currentPair.CurrentOpponent) > playerPairs.IndexOf(lowestAllocatedPair))
                                                {
                                                    //Set lowestAllocatedPair to the current player's opponent
                                                    //(The highest ranked member of the new lowest ranked allocated pair)
                                                    lowestAllocatedPair = currentPair.CurrentOpponent;
                                                }
                                            }
                                            //Proceed if the current player has a higher rank than their opponent
                                            else if (playerPairs.IndexOf(currentPair) < playerPairs.IndexOf(currentPair.CurrentOpponent))
                                            {
                                                //Proceed if the current player has a lower rank than the previous value of lowestAllocatedPair
                                                if (playerPairs.IndexOf(currentPair) > playerPairs.IndexOf(lowestAllocatedPair))
                                                {
                                                    //Set lowestAllocatedPair to the current player
                                                    //(The highest ranked member of the new lowest ranked allocated pair)
                                                    lowestAllocatedPair = currentPair;
                                                }
                                            }
                                        }
                                    }
                                    //Set the new player to be allocated to the highest member of the lowestAllocatedPair
                                    i = playerPairs.IndexOf(lowestAllocatedPair) - 1;
                                    //Set the starting player that will be tested for allocation suitability to one rank lower than
                                    //the opponent of the highest member of the allocated pair
                                    secondaryIndex = playerPairs.IndexOf(lowestAllocatedPair.CurrentOpponent) + 1;

                                    //Deallocate the lowest allocated pair as each other's opponent
                                    lowestAllocatedPair.CurrentOpponent.CurrentOpponent = null;
                                    lowestAllocatedPair.CurrentOpponent = null;
                                }
                            }
                        }
                    }
                }
                i++;
            }
            int newRound = lastRound + 1;

            foreach (PlayerPair playerPair in playerPairs)
            {
                if (playerPairs.IndexOf(playerPair) < playerPairs.IndexOf(playerPair.CurrentOpponent))
                {
                    PairRoundMatchup roundMatchup = new PairRoundMatchup
                    {
                        RoundNo     = newRound,
                        PlayerOne   = playerPair.First,
                        PlayerTwo   = playerPair.Second,
                        PlayerThree = playerPair.CurrentOpponent.First,
                        PlayerFour  = playerPair.CurrentOpponent.Second
                    };

                    //allocates table for matchup
                    //roundMatchup.Table = AllocateTable(GetTables(player), AllocatedTables);

                    _context.Add(roundMatchup);
                }
            }

            _context.SaveChanges();
        }
Exemple #2
0
        public static Boolean GenerateNextPairRound(TournamentDbContext _context)
        {
            Boolean           error             = false;
            int               lastRound         = GetLastRoundNo(_context);
            var               roundMatchups     = _context.RoundMatchups.Where(r => !(r is PairRoundMatchup)).Include(r => r.PlayerOne).Include(r => r.PlayerTwo).Where(r => r.RoundNo == lastRound).ToList();
            var               pairRoundMatchups = _context.PairRoundMatchups.Include(r => r.PlayerOne).Include(r => r.PlayerTwo).Include(r => r.PlayerThree).Include(r => r.PlayerFour).Where(r => r.RoundNo == lastRound).ToList();
            List <Player>     activePlayers     = _context.Players.Where(p => p.Active && p.Bye == false).ToList();
            List <Player>     activeByePlayers  = new List <Player>();
            List <PlayerPair> playerPairs       = new List <PlayerPair>();

            roundMatchups = roundMatchups.Union(pairRoundMatchups).ToList();

            if (roundMatchups != null)
            {
                Tuple <List <PlayerPair>, List <Player> > playerPairsAndByes = (RoundMatchupActions.GetPlayerPairs(roundMatchups, activePlayers));
                playerPairs      = playerPairsAndByes.Item1;
                activeByePlayers = playerPairsAndByes.Item2;
            }
            else
            {
                error = true;
            }

            //List<int> AllocatedTables = new List<int>(GetnoOfTables());
            int secondaryIndex = 0;
            int i = 0;

            while (i < playerPairs.Count && i >= 0)
            {
                //Skip this player if they are already allocated an opponent
                if (playerPairs[i].CurrentOpponent == null)
                {
                    if (secondaryIndex == 0)
                    {
                        secondaryIndex = i + 1;
                    }
                    int s = 0;

                    for (s = secondaryIndex; s < playerPairs.Count; s++)
                    {
                        //If there are no more unique matchups, exit
                        if (i == -1)
                        {
                            i     = -2;
                            error = true;
                            break;
                        }
                        if (playerPairs[s].CurrentOpponent == null)
                        {
                            //Check if higher player has ever played lower player
                            var playerOneOpponents = PlayerActions.GetAllOpponents(playerPairs[i].First, _context);
                            var playerTwoOpponents = PlayerActions.GetAllOpponents(playerPairs[i].Second, _context);
                            var opponents          = playerOneOpponents.Union(playerTwoOpponents);
                            var hasPlayed          = false;
                            foreach (Player opponent in opponents)
                            {
                                if (playerPairs[s].First == opponent || playerPairs[s].Second == opponent)
                                {
                                    hasPlayed = true;
                                }
                            }
                            //If they have not played allocate them as opponents
                            if (hasPlayed == false)
                            {
                                playerPairs[i].CurrentOpponent = playerPairs[s];
                                playerPairs[s].CurrentOpponent = playerPairs[i];
                                secondaryIndex = 0;
                                break;
                            }

                            /**
                             * Following block is to deallocate the next lowest ranked allocated pair
                             **/
                            if (playerPairs.Where(p => p.CurrentOpponent == null).LastOrDefault() == playerPairs[s] && (playerPairs[i].CurrentOpponent == null))
                            //if (s == (players.Count - 1) && (players[i].CurrentOpponent == null))
                            {
                                if (i - 1 >= 0)
                                {
                                    //Set the lowestAllocatedPair to the highest ranked pair
                                    PlayerPair lowestAllocatedPair = playerPairs[0];
                                    //Iterate from the second highest ranked pair all the way to the pair ranked one higher than the player currently being matched
                                    for (int playerIndex = 1; playerIndex < i; playerIndex++)
                                    {
                                        //Assign the current player to the player being examined in the current iteration of the loop
                                        PlayerPair currentPair = playerPairs[playerIndex];

                                        //Check that the current player has an opponent (if not, skip to the next iteration of the loop)
                                        if (currentPair.CurrentOpponent != null)
                                        {
                                            //Proceed if the current player's opponent has a higher rank than the current player
                                            if (playerPairs.IndexOf(currentPair.CurrentOpponent) < playerPairs.IndexOf(currentPair))
                                            {
                                                if (playerPairs.IndexOf(currentPair.CurrentOpponent) > playerPairs.IndexOf(lowestAllocatedPair))
                                                {
                                                    //Set lowestAllocatedPair to the current player's opponent
                                                    //(The highest ranked member of the new lowest ranked allocated pair)
                                                    lowestAllocatedPair = currentPair.CurrentOpponent;
                                                }
                                            }
                                            //Proceed if the current player has a higher rank than their opponent
                                            else if (playerPairs.IndexOf(currentPair) < playerPairs.IndexOf(currentPair.CurrentOpponent))
                                            {
                                                //Proceed if the current player has a lower rank than the previous value of lowestAllocatedPair
                                                if (playerPairs.IndexOf(currentPair) > playerPairs.IndexOf(lowestAllocatedPair))
                                                {
                                                    //Set lowestAllocatedPair to the current player
                                                    //(The highest ranked member of the new lowest ranked allocated pair)
                                                    lowestAllocatedPair = currentPair;
                                                }
                                            }
                                        }
                                    }
                                    //Set the new player to be allocated to the highest member of the lowestAllocatedPair
                                    i = playerPairs.IndexOf(lowestAllocatedPair) - 1;

                                    //If there are no more unique matchups, exit
                                    if (i == -1)
                                    {
                                        i     = -2;
                                        error = true;
                                        break;
                                    }

                                    //Set the starting player that will be tested for allocation suitability to one rank lower than
                                    //the opponent of the highest member of the allocated pair
                                    secondaryIndex = playerPairs.IndexOf(lowestAllocatedPair.CurrentOpponent) + 1;

                                    //Deallocate the lowest allocated pair as each other's opponent
                                    lowestAllocatedPair.CurrentOpponent.CurrentOpponent = null;
                                    lowestAllocatedPair.CurrentOpponent = null;
                                }
                                else
                                {
                                    i     = -2;
                                    error = true;
                                    break;
                                }
                            }
                        }
                    }
                }
                i++;
            }
            int newRoundNo = lastRound + 1;

            foreach (PlayerPair playerPair in playerPairs)
            {
                if (playerPairs.IndexOf(playerPair) < playerPairs.IndexOf(playerPair.CurrentOpponent))
                {
                    var roundMatchup = new PairRoundMatchup
                    {
                        RoundNo     = newRoundNo,
                        PlayerOne   = playerPair.First,
                        PlayerTwo   = playerPair.Second,
                        PlayerThree = playerPair.CurrentOpponent.First,
                        PlayerFour  = playerPair.CurrentOpponent.Second
                    };

                    //allocates table for matchup
                    //roundMatchup.Table = AllocateTable(GetTables(player), AllocatedTables);

                    _context.Add(roundMatchup);
                }
                //If there are no more unique matchups
                if (error)
                {
                    //RoundMatchup will hold random pair matchups where teammates were opponents last round unless their opponent is no longer active or has a bye
                    if (playerPair.CurrentOpponent == null && playerPairs[playerPairs.IndexOf(playerPair) + 1] != null)
                    {
                        playerPair.CurrentOpponent = playerPairs[playerPairs.IndexOf(playerPair) + 1];
                        playerPair.CurrentOpponent.CurrentOpponent = playerPair;
                        var roundMatchup = new PairRoundMatchup
                        {
                            RoundNo     = newRoundNo,
                            PlayerOne   = playerPair.First,
                            PlayerTwo   = playerPair.Second,
                            PlayerThree = playerPair.CurrentOpponent.First,
                            PlayerFour  = playerPair.CurrentOpponent.Second
                        };
                        _context.Add(roundMatchup);
                    }
                }
            }

            CreateByeRounds(activeByePlayers, newRoundNo, _context);

            _context.SaveChanges();

            if (error)
            {
                return(false);
            }
            return(true);
        }