Ejemplo n.º 1
0
        private PlayerResponse GetPlayer(int?playerId = null, string username = null)
        {
            var row = _context.Players
                      .Include(x => x.Badges)
                      .Include(x => x.Matches)
                      .ThenInclude(x => x.Match)
                      .Select(x => new {
                LastMatch = x.Matches.OrderByDescending(x => x.Match.StartDate).FirstOrDefault(),
                Player    = x
            })
                      .FirstOrDefault(x => string.IsNullOrEmpty(username) ? x.Player.Id == playerId : x.Player.Username == username);

            if (row == null)
            {
                throw new NotFoundException("Player not found");
            }

            var response = _mapper.Map <PlayerResponse>(row.Player);

            response.ConservativeRating = _ratingService.GetConservative(row.Player.RatingMean, row.Player.RatingDeviation);

            if (row.LastMatch != null)
            {
                response.MatchId = row.LastMatch.MatchId.ToString();
                var decayStep = _decayService.GetDecaySteps(row.LastMatch.DecayDays, row.LastMatch.Match.StartDate);
                response.TotalDecay  = _decayService.GetDecayValues(decayStep);
                response.RegainDecay = _decayService.GetDecayValue(decayStep);
            }

            return(response);
        }
Ejemplo n.º 2
0
        private int GetPlayerDecay(Player player)
        {
            if (player.Division != Division.Master)
            {
                return(0);
            }
            var lastMatch = GetLastMatchByPlayerId(player.Id);

            if (lastMatch == null)
            {
                return(0);
            }
            var previousDecay = lastMatch.MatchPlayers.ToList().Where(x => x.PlayerId == player.Id).Select(x => x.DecayDays).FirstOrDefault();

            return(_decayService.GetDecaySteps(previousDecay, lastMatch.StartDate));
        }
Ejemplo n.º 3
0
        public void RerateAll()
        {
            var players = _context.Players
                          .Include(x => x.Matches)
                          .ToList();

            // Reset player ratings to their initial values
            var ratings = new Dictionary <int, PlayerRating>();

            foreach (var p in players)
            {
                ratings.Add(p.Id, GetDefaultRating());
            }
            ratings[1442].Level = 1;

            var matches = _context.Matches
                          .Include(x => x.MatchPlayers)
                          .Where(x => x.Status != MatchStatus.InProgress)
                          .OrderBy(x => x.StartDate)
                          .ToList();

            foreach (var match in matches)
            {
                foreach (var matchPlayer in match.MatchPlayers)
                {
                    var playerRating = ratings.GetValueOrDefault(matchPlayer.PlayerId, GetDefaultRating());
                    var currentDecay = _decayService.GetDecaySteps(playerRating.DecayDays, playerRating.LastMatchTimestamp, match.StartDate);

                    matchPlayer.Player.Division    = playerRating.Division;
                    matchPlayer.Player.Level       = playerRating.Level;
                    matchPlayer.OldRatingMean      = playerRating.RatingMean;
                    matchPlayer.OldRatingDeviation = playerRating.RatingDeviation;
                    matchPlayer.DecayDays          = currentDecay;
                }
                RateMatch(match);
                foreach (var matchPlayer in match.MatchPlayers)
                {
                    var playerRating = ratings.GetValueOrDefault(matchPlayer.PlayerId, GetDefaultRating());
                    var newDivision  = GetNewDivisionAndLevel(playerRating.Division, playerRating.Level, matchPlayer.IsWin);
                    playerRating.Division           = newDivision.Division;
                    playerRating.Level              = newDivision.Level;
                    playerRating.RatingMean         = matchPlayer.NewRatingMean;
                    playerRating.RatingDeviation    = matchPlayer.NewRatingDeviation;
                    playerRating.DecayDays          = matchPlayer.DecayDays;
                    playerRating.LastMatchTimestamp = match.StartDate;
                }
                if (match.Id % 10 == 0)
                {
                    _context.SaveChanges();
                }
            }

            foreach (var p in players)
            {
                p.RatingMean      = ratings[p.Id].RatingMean;
                p.RatingDeviation = ratings[p.Id].RatingDeviation;
                p.Division        = ratings[p.Id].Division;
                p.Level           = ratings[p.Id].Level;
            }

            _context.SaveChanges();
        }