Пример #1
0
        private void CreateNextStepBrackets(Group parentGroup, Group childGroup)
        {
            var parentBracketGroups = parentGroup.PlayoffBrackets.GroupBy(b => new { b.Stage, b.MinPos, b.MaxPos });

            List <PlayoffBracket> nextBrackets = new List <PlayoffBracket>();

            foreach (var brackets in parentBracketGroups)
            {
                int minPos    = brackets.Key.MinPos;
                int maxPos    = brackets.Key.MaxPos;
                int middelPos = ((brackets.Key.MinPos - brackets.Key.MaxPos) / 2) + brackets.Key.MaxPos;
                int stage     = brackets.Key.Stage + 1;

                int startIndex = 0;
                int endIndex   = brackets.Count() - 1;
                for (int i = 0; i < brackets.Count() / 2; i++)
                {
                    var parent1 = brackets.ElementAt(startIndex);
                    startIndex++;
                    var parent2 = brackets.ElementAt(endIndex);
                    endIndex--;
                    PlayoffBracket winnerBracket = new PlayoffBracket();
                    winnerBracket.Team1Id          = parent1.WinnerId;
                    winnerBracket.Team2Id          = parent2.WinnerId;
                    winnerBracket.Stage            = stage;
                    winnerBracket.MaxPos           = maxPos;
                    winnerBracket.MinPos           = middelPos;
                    winnerBracket.Type             = (int)PlayoffBracketType.Winner;
                    winnerBracket.ParentBracket1Id = parent1.Id;
                    winnerBracket.ParentBracket2Id = parent2.Id;
                    winnerBracket.GroupId          = childGroup.GroupId;
                    nextBrackets.Add(winnerBracket);


                    if (childGroup.TypeId == 2)
                    {
                        PlayoffBracket loserBracket = new PlayoffBracket();
                        loserBracket.Team1Id          = parent1.LoserId;
                        loserBracket.Team2Id          = parent2.LoserId;
                        loserBracket.Stage            = brackets.Key.Stage + 1;
                        loserBracket.MaxPos           = middelPos + 1;
                        loserBracket.MinPos           = minPos;
                        loserBracket.Type             = (int)PlayoffBracketType.Loseer;
                        loserBracket.ParentBracket1Id = parent1.Id;
                        loserBracket.ParentBracket2Id = parent2.Id;
                        loserBracket.GroupId          = childGroup.GroupId;
                        nextBrackets.Add(loserBracket);
                    }
                }
            }
            var list = nextBrackets.OrderBy(b => b.Type).ToList();

            bracketsRepo.SaveBrackets(list);
        }
Пример #2
0
        private int CreateBracketsForEarlyStagePlayoffGroup(Group group)
        {
            group.IsAdvanced = true;
            List <int> groupTeamsIds   = group.GroupsTeams.Where(gt => gt.Team.IsArchive == false).OrderBy(gt => gt.Pos).Select(gt => gt.TeamId).ToList();
            List <int> ligitTeamCounts = new List <int> {
                2, 4, 8, 16, 32, 64
            };
            int numberOfTeams = groupTeamsIds.Count;
            int ligitNumber   = 0;

            foreach (var num in ligitTeamCounts)
            {
                if (numberOfTeams <= num)
                {
                    ligitNumber = num;
                    break;
                }
            }

            for (int i = numberOfTeams; i < ligitNumber; i++)
            {
                groupTeamsIds.Add(0);
            }

            List <Tuple <int, int> > combinations = CreatePlayoffCombinations(groupTeamsIds);
            List <PlayoffBracket>    brackets     = new List <PlayoffBracket>();

            foreach (var comb in combinations)
            {
                PlayoffBracket b = new PlayoffBracket
                {
                    Team1Id = comb.Item1,
                    Team2Id = comb.Item2,
                    MaxPos  = 1,
                    MinPos  = combinations.Count * 2,
                    Stage   = 1,
                    Type    = (int)PlayoffBracketType.Root
                };

                if (comb.Item2 == 0)
                {
                    b.Team2Id  = null;
                    b.WinnerId = comb.Item1;
                }

                brackets.Add(b);
            }
            group.PlayoffBrackets = brackets;
            groupesRepo.Save();
            return(ligitNumber);
        }
Пример #3
0
        private void FindTeamsRecursively(PlayoffBracket bracket, List <Team> list, int index)
        {
            if (bracket.Type == (int)PlayoffBracketType.Root)
            {
                if (bracket.Team1Id != null)
                {
                    list.Add(bracket.FirstTeam);
                }

                if (bracket.Team2Id != null)
                {
                    list.Add(bracket.SecondTeam);
                }
            }
            else
            {
                PlayoffBracket parent;
                if (index == 1)
                {
                    parent = bracket.Parent1;
                }
                else
                {
                    parent = bracket.Parent2;
                }

                if (parent.Team1Id != null)
                {
                    list.Add(parent.FirstTeam);
                }
                else
                {
                    FindTeamsRecursively(parent, list, 1);
                }

                if (parent.Team2Id != null)
                {
                    list.Add(parent.SecondTeam);
                }
                else
                {
                    FindTeamsRecursively(parent, list, 2);
                }
            }
        }
Пример #4
0
        internal void GameEndedEvent(GamesCycle gc)
        {
            PlayoffBracket bracket = gc.PlayoffBracket;

            if (bracket != null && bracket.GamesCycles.All(g => g.GameStatus == GameStatus.Ended))
            {
                var goldenGame = bracket.GamesCycles.FirstOrDefault(g => g.GameSets.Any(s => s.IsGoldenSet == true));

                if (goldenGame != null)
                {
                    gameRepo.ResetGame(goldenGame, true);

                    var goldenSet = goldenGame.GameSets.FirstOrDefault(s => s.IsGoldenSet == true);
                    if (goldenSet.HomeTeamScore > goldenSet.GuestTeamScore)
                    {
                        bracket.WinnerId = goldenGame.HomeTeamId;
                        bracket.LoserId  = goldenGame.GuestTeamId;
                    }
                    else
                    {
                        bracket.WinnerId = goldenGame.GuestTeamId;
                        bracket.LoserId  = goldenGame.HomeTeamId;
                    }
                }
                else
                {
                    int t1score = bracket.GamesCycles.Where(g => g.HomeTeamId == bracket.FirstTeam?.TeamId && g.HomeTeamScore > g.GuestTeamScore)
                                  .Concat(bracket.GamesCycles.Where(g => g.GuestTeamId == bracket.FirstTeam?.TeamId && g.HomeTeamScore < g.GuestTeamScore)).Count();

                    int t2score = bracket.GamesCycles.Where(g => g.HomeTeamId == bracket.SecondTeam?.TeamId && g.HomeTeamScore > g.GuestTeamScore)
                                  .Concat(bracket.GamesCycles.Where(g => g.GuestTeamId == bracket.SecondTeam?.TeamId && g.HomeTeamScore < g.GuestTeamScore)).Count();

                    if (t1score > t2score)
                    {
                        bracket.WinnerId = bracket.FirstTeam.TeamId;
                        bracket.LoserId  = bracket.SecondTeam.TeamId;
                    }
                    else if (t1score < t2score)
                    {
                        bracket.WinnerId = bracket.SecondTeam.TeamId;
                        bracket.LoserId  = bracket.FirstTeam.TeamId;
                    }
                }


                foreach (var child in bracket.ChildrenSide1)
                {
                    if (child.Type == (int)PlayoffBracketType.Winner)
                    {
                        child.Team1Id = bracket.WinnerId;
                    }
                    else if (child.Type == (int)PlayoffBracketType.Loseer)
                    {
                        child.Team1Id = bracket.LoserId;
                    }

                    for (int i = 0; i < child.GamesCycles.Count; i++)
                    {
                        GamesCycle game = child.GamesCycles.ElementAt(i);
                        gameRepo.ResetGame(game, true);
                        if (i % 2 == 0)
                        {
                            game.HomeTeamId  = child.Team1Id;
                            game.GuestTeamId = child.Team2Id;
                        }
                        else
                        {
                            game.HomeTeamId  = child.Team2Id;
                            game.GuestTeamId = child.Team1Id;
                        }
                    }
                }


                foreach (var child in bracket.ChildrenSide2)
                {
                    if (child.Type == (int)PlayoffBracketType.Winner)
                    {
                        child.Team2Id = bracket.WinnerId;
                    }
                    else if (child.Type == (int)PlayoffBracketType.Loseer)
                    {
                        child.Team2Id = bracket.LoserId;
                    }
                    for (int i = 0; i < child.GamesCycles.Count; i++)
                    {
                        GamesCycle game = child.GamesCycles.ElementAt(i);
                        gameRepo.ResetGame(game, true);
                        if (i % 2 == 0)
                        {
                            game.HomeTeamId  = child.Team1Id;
                            game.GuestTeamId = child.Team2Id;
                        }
                        else
                        {
                            game.HomeTeamId  = child.Team2Id;
                            game.GuestTeamId = child.Team1Id;
                        }
                    }
                }
            }
            Save();
        }