Пример #1
0
        public IEnumerable <ShowTournamentLadderChallengeViewModel> CalculateTournamentLadderChallenge(CalculateTournamentLadderChallengeViewModel viewModel)
        {
            ProgressReporterProvider.Current.ReportProgress(string.Format("Calculating tournament ladder challenge for {0}-{1}", viewModel.Tournament, viewModel.StartDate.ToShortDateString()), ReporterImportance.High, ReporterAudience.Admin);

            var ladders = this.tennisFixtureService.GetTournamentLadder(viewModel.StartDate, viewModel.Tournament);

            if (ladders.Count() == 0)
            {
                return(Enumerable.Empty <ShowTournamentLadderChallengeViewModel>());
            }

            var tournament = this.tennisFixtureService.GetTournament(viewModel.Tournament);

            var seed = new List <ShowTournamentLadderChallengeViewModel>();

            foreach (var ladder in ladders)
            {
                var openingRound = new ShowTournamentLadderChallengeViewModel
                {
                    ExpectedWinner          = string.Format("{0}, {1}", ladder.PlayerSurname, ladder.PlayerFirstName),
                    ExpectedWinnerFirstName = ladder.PlayerFirstName,
                    ExpectedWinnerSurname   = ladder.PlayerSurname,
                    RoundNumber             = 0
                };
                seed.Add(openingRound);
            }

            return
                (CalculateRoundTournamentLadderChallenge(seed, tournament.Slug, viewModel.StartDate.AddDays(3).Year, 1)
                 .Where(x => x.RoundNumber > 0));
        }
Пример #2
0
        private IList <ShowTournamentLadderChallengeViewModel> CalculateRoundTournamentLadderChallenge(IList <ShowTournamentLadderChallengeViewModel> seed,
                                                                                                       string tournamentSlug, int year, int round)
        {
            var previousRoundMatches
                = seed.Where(x => x.RoundNumber == round - 1)
                  .ToList();

            if (previousRoundMatches.Count() <= 1)
            {
                return(seed);
            }

            for (int i = 0; i < previousRoundMatches.Count; i += 2)
            {
                var viewModel = new ShowTournamentLadderChallengeViewModel()
                {
                    RoundNumber = round
                };
                int shift      = 0;
                int loserShift = 0;

                if (previousRoundMatches[i + 1].ExpectedWinnerSurname == "Bye")
                {
                    shift                 = i;
                    loserShift            = i + 1;
                    viewModel.Probability = 1;
                }
                else if (previousRoundMatches[i].ExpectedWinnerSurname == "Bye")
                {
                    shift                 = i + 1;
                    loserShift            = i;
                    viewModel.Probability = 1;
                }
                else
                {
                    bool playerAGoesThrough = true;
                    var  prediction         = this.tennisPredictionService.GetSingleTennisPrediction(
                        previousRoundMatches[i].ExpectedWinnerSurname.Replace(".", ""),
                        previousRoundMatches[i].ExpectedWinnerFirstName.Replace(".", ""),
                        previousRoundMatches[i + 1].ExpectedWinnerSurname.Replace(".", ""),
                        previousRoundMatches[i + 1].ExpectedWinnerFirstName.Replace(".", ""),
                        year,
                        tournamentSlug,
                        false /*we don't want to accidentally introduce hindsight*/);

                    if (prediction.Predictions.Probabilities["HomeWin"] > prediction.Predictions.Probabilities["AwayWin"])
                    {
                        playerAGoesThrough = true;
                    }
                    else if (prediction.Predictions.Probabilities["HomeWin"] < prediction.Predictions.Probabilities["AwayWin"])
                    {
                        playerAGoesThrough = false;
                    }
                    else
                    {
                        playerAGoesThrough = prediction.Predictions.PlayerAGames >= prediction.Predictions.PlayerBGames;
                    }

                    shift                 = playerAGoesThrough ? i : (i + 1);
                    loserShift            = playerAGoesThrough ? (i + 1) : i;
                    viewModel.Probability = playerAGoesThrough ? prediction.Predictions.Probabilities["HomeWin"] : prediction.Predictions.Probabilities["AwayWin"];
                }
                viewModel.ExpectedWinner          = previousRoundMatches[shift].ExpectedWinner;
                viewModel.ExpectedWinnerFirstName = previousRoundMatches[shift].ExpectedWinnerFirstName;
                viewModel.ExpectedWinnerSurname   = previousRoundMatches[shift].ExpectedWinnerSurname;
                viewModel.ExpectedLoser           = previousRoundMatches[loserShift].ExpectedWinner;
                viewModel.ExpectedLoserFirstName  = previousRoundMatches[loserShift].ExpectedLoserFirstName;
                viewModel.ExpectedLoserSurname    = previousRoundMatches[loserShift].ExpectedLoserSurname;

                seed.Add(viewModel);
            }


            return(CalculateRoundTournamentLadderChallenge(seed, tournamentSlug, year, round + 1));
        }
    private async Task<IList<ShowTournamentLadderChallengeViewModel>> CalculateRoundTournamentLadderChallenge(IList<ShowTournamentLadderChallengeViewModel> seed,
      string tournamentSlug, int year, int round)
    {
      var previousRoundMatches
        = seed.Where(x => x.RoundNumber == round - 1)
              .ToList();

      if (previousRoundMatches.Count() <= 1)
        return seed;

      for (int i = 0; i < previousRoundMatches.Count; i += 2)
      {
        var viewModel = new ShowTournamentLadderChallengeViewModel() { RoundNumber = round };
        int shift = 0;
        int loserShift = 0;

        if (previousRoundMatches[i + 1].ExpectedWinnerSurname == "Bye")
        {
          shift = i;
          loserShift = i + 1;
          viewModel.Probability = 1;
        }
        else if (previousRoundMatches[i].ExpectedWinnerSurname == "Bye")
        {
          shift = i + 1;
          loserShift = i;
          viewModel.Probability = 1;
        }
        else
        {
          bool playerAGoesThrough = true;
          var prediction = await 
            this.tennisPredictionService.GetSingleTennisPrediction(
              previousRoundMatches[i].ExpectedWinnerSurname,
              previousRoundMatches[i].ExpectedWinnerFirstName,
              previousRoundMatches[i + 1].ExpectedWinnerSurname,
              previousRoundMatches[i + 1].ExpectedWinnerFirstName,
              year,
              tournamentSlug,
              false /*we don't want to accidentally introduce hindsight*/);

          if (prediction.Predictions.Probabilities["homeWin"] > prediction.Predictions.Probabilities["awayWin"])
            playerAGoesThrough = true;
          else if (prediction.Predictions.Probabilities["homeWin"] < prediction.Predictions.Probabilities["awayWin"])
            playerAGoesThrough = false;
          else
            playerAGoesThrough = prediction.Predictions.PlayerAGames >= prediction.Predictions.PlayerBGames;

          shift = playerAGoesThrough ? i : (i + 1);
          loserShift = playerAGoesThrough ? (i + 1) : i;
          viewModel.Probability = playerAGoesThrough ? prediction.Predictions.Probabilities["homeWin"] : prediction.Predictions.Probabilities["awayWin"];
        }
        viewModel.ExpectedWinner = previousRoundMatches[shift].ExpectedWinner;
        viewModel.ExpectedWinnerFirstName = previousRoundMatches[shift].ExpectedWinnerFirstName;
        viewModel.ExpectedWinnerSurname = previousRoundMatches[shift].ExpectedWinnerSurname;
        viewModel.ExpectedLoser = previousRoundMatches[loserShift].ExpectedWinner;
        viewModel.ExpectedLoserFirstName = previousRoundMatches[loserShift].ExpectedLoserFirstName;
        viewModel.ExpectedLoserSurname = previousRoundMatches[loserShift].ExpectedLoserSurname;

        seed.Add(viewModel);
      }


      return await CalculateRoundTournamentLadderChallenge(seed, tournamentSlug, year, round + 1);
    }
Пример #4
0
    public IEnumerable<ShowTournamentLadderChallengeViewModel> CalculateTournamentLadderChallenge(CalculateTournamentLadderChallengeViewModel viewModel)
    {
      ProgressReporterProvider.Current.ReportProgress(string.Format("Calculating tournament ladder challenge for {0}-{1}", viewModel.Tournament, viewModel.StartDate.ToShortDateString()), ReporterImportance.High, ReporterAudience.Admin);

      var ladders = this.tennisFixtureService.GetTournamentLadder(viewModel.StartDate, viewModel.Tournament);
      if (ladders.Count() == 0)
        return Enumerable.Empty<ShowTournamentLadderChallengeViewModel>();

      var tournament = this.tennisFixtureService.GetTournament(viewModel.Tournament);

      var seed = new List<ShowTournamentLadderChallengeViewModel>();

      foreach (var ladder in ladders)
      {
        var openingRound = new ShowTournamentLadderChallengeViewModel
        {
          ExpectedWinner = string.Format("{0}, {1}", ladder.PlayerSurname, ladder.PlayerFirstName),
          ExpectedWinnerFirstName = ladder.PlayerFirstName,
          ExpectedWinnerSurname = ladder.PlayerSurname,
          RoundNumber = 0
        };
        seed.Add(openingRound);
      }

      return
        CalculateRoundTournamentLadderChallenge(seed, tournament.Slug, viewModel.StartDate.AddDays(3).Year, 1)
          .Where(x => x.RoundNumber > 0);
    }