예제 #1
0
        private void SetTeams(ITeamMatch match, List <ArenaPlayer> players, ArenaMatchResult result, string gamerTag)
        {
            result.Teams = new List <Team>();
            foreach (var teamStat in match.TeamStats.OrderBy(t => t.Rank))
            {
                var team = Mapper.Map <Team>(teamStat);
                team.Players = players.Where(p => p.TeamId == teamStat.TeamId).OrderBy(p => p.Rank).ToList();

                var minKills   = team.Players.Min(p => p.TotalKills);
                var maxKills   = team.Players.Max(p => p.TotalKills) - minKills;
                var minDeaths  = team.Players.Min(p => p.TotalDeaths);
                var maxDeaths  = team.Players.Max(p => p.TotalDeaths) - minDeaths;
                var minAssists = team.Players.Min(p => p.TotalAssists);
                var maxAssists = team.Players.Max(p => p.TotalAssists) - minAssists;
                var maxKda     = team.Players.Max(p => p.Kda);
                var minKda     = team.Players.Min(p => p.Kda);

                foreach (var p in team.Players)
                {
                    p.KillPercent   = p.TotalKills.Percent(minKills, maxKills);
                    p.DeathPercent  = p.TotalDeaths.Percent(minDeaths, maxDeaths);
                    p.AssistPercent = p.TotalAssists.Percent(minAssists, maxAssists);
                    p.KdaPercent    = p.Kda.Percent(p.Kda < 0 ? minKda : maxKda);
                }

                result.Teams.Add(team);
            }

            var player      = players.FirstOrDefault(p => p.GamerTag.ToUpper() == gamerTag.ToUpper());
            var playersTeam = result.Teams.FirstOrDefault(t => t.TeamId == player?.TeamId);

            if (playersTeam != null && player != null)
            {
                if (player.DNF)
                {
                    result.Result = Enumeration.ResultType.DidNotFinish;
                }
                else if (playersTeam.Rank == 0)
                {
                    result.Result = result.Teams.Any(t => t.TeamId != playersTeam.TeamId && t.Rank == 0) ? Enumeration.ResultType.Tied : Enumeration.ResultType.Won;
                }
                else
                {
                    result.Result = Enumeration.ResultType.Lost;
                }
                result.PlayerTeamColor = playersTeam.TeamColor;
            }
        }
예제 #2
0
        private void SetTeams(ITeamMatch match, List <ArenaPlayer> players, MatchResult result, string gamerTag)
        {
            result.Teams = new List <Team>();
            foreach (var teamStat in match.TeamStats.OrderBy(t => t.Rank))
            {
                var team = Mapper.Map <Team>(teamStat);
                team.Players = players.Where(p => p.TeamId == teamStat.TeamId).OrderBy(p => p.Rank).ToList();

                int minTotalKills = team.Players.Min(p => p.TotalKills);
                int maxTotalKills = team.Players.Max(p => p.TotalKills) - minTotalKills;

                int minDeaths = team.Players.Min(p => p.TotalDeaths);
                int maxDeaths = team.Players.Max(p => p.TotalDeaths) - minDeaths;

                int minAssists = team.Players.Min(p => p.TotalAssists);
                int maxAssists = team.Players.Max(p => p.TotalAssists) - minAssists;

                double maxKda = team.Players.Max(p => p.Kda);
                double minKda = team.Players.Min(p => p.Kda);

                int minHeadshots = team.Players.Min(p => p.TotalHeadshots);
                int maxHeadshots = team.Players.Max(p => p.TotalHeadshots) - minHeadshots;

                int minPerfectKill = team.Players.Min(p => p.TotalPerfectKills);
                int maxPerfectKill = team.Players.Max(p => p.TotalPerfectKills) - minPerfectKill;

                int minRoundWinningKills = team.Players.Min(p => p.RoundWinningKills);
                int maxRoundWinningKills = team.Players.Max(p => p.RoundWinningKills) - minRoundWinningKills;

                int minFlagCaptures     = team.Players.Min(p => p.FlagCaptures);
                int maxFlagCaptures     = team.Players.Max(p => p.FlagCaptures) - minFlagCaptures;
                int minFlagPulls        = team.Players.Min(p => p.FlagPulls);
                int maxFlagPulls        = team.Players.Max(p => p.FlagPulls) - minFlagPulls;
                int minFlagCarrierKills = team.Players.Min(p => p.FlagCarrierKills);
                int maxFlagCarrierKills = team.Players.Max(p => p.FlagCarrierKills) - minFlagCarrierKills;

                int minStrongHoldsCaptured = team.Players.Min(p => p.StrongholdsCaptured);
                int maxStrongHoldsCaptured = team.Players.Max(p => p.StrongholdsCaptured) - minStrongHoldsCaptured;
                int minStrongholdsSecured  = team.Players.Min(p => p.StrongholdsSecured);
                int maxStrongholdsSecured  = team.Players.Max(p => p.StrongholdsSecured) - minStrongholdsSecured;
                int minStrongholdsDefended = team.Players.Min(p => p.StrongholdsDefended);
                int maxStrongholdsDefended = team.Players.Max(p => p.StrongholdsDefended) - minStrongholdsDefended;

                int minScore          = team.Players.Min(p => p.Score);
                int maxScore          = team.Players.Max(p => p.Score) - minScore;
                int minKills          = team.Players.Min(p => p.Kills);
                int maxKills          = team.Players.Max(p => p.Kills) - minKills;
                int minRoundsSurvived = team.Players.Min(p => p.RoundsSurvived);
                int maxRoundsSurvived = team.Players.Max(p => p.RoundsSurvived) - minRoundsSurvived;
                int minRoundsComplete = team.Players.Min(p => p.RoundsComplete);
                int maxRoundsComplete = team.Players.Max(p => p.RoundsComplete) - minRoundsComplete;
                int minBossTakedowns  = team.Players.Min(p => p.BossTakedowns);
                int maxBossTakedowns  = team.Players.Max(p => p.BossTakedowns) - minBossTakedowns;

                int minTotalSpartanKills = team.Players.Min(p => p.TotalSpartanKills);
                int maxTotalSpartanKills = team.Players.Max(p => p.TotalSpartanKills) - minTotalSpartanKills;
                int minNpcKills          = team.Players.Min(p => p.NpcKills);
                int maxNpcKills          = team.Players.Max(p => p.NpcKills) - minNpcKills;

                foreach (var p in team.Players)
                {
                    p.TotalKillPercent         = p.TotalKills.Percent(minTotalKills, maxTotalKills);
                    p.DeathPercent             = p.TotalDeaths.Percent(minDeaths, maxDeaths);
                    p.AssistPercent            = p.TotalAssists.Percent(minAssists, maxAssists);
                    p.KdaPercent               = p.Kda.Percent(p.Kda < 0 ? minKda : maxKda);
                    p.HeadshotPercent          = p.TotalHeadshots.Percent(minHeadshots, maxHeadshots);
                    p.RoundWinningKillsPercent = p.RoundWinningKills.Percent(minRoundWinningKills, maxRoundWinningKills);
                    p.PerfectKillPercent       = p.TotalPerfectKills.Percent(minPerfectKill, maxPerfectKill);
                    p.FlagCapturePercent       = p.FlagCaptures.Percent(minFlagCaptures, maxFlagCaptures);
                    p.FlagPullPercent          = p.FlagPulls.Percent(minFlagPulls, maxFlagPulls);
                    p.FlagCarrierKillPercent   = p.FlagCarrierKills.Percent(minFlagCarrierKills, maxFlagCarrierKills);
                    p.StrongholdCapturePercent = p.StrongholdsCaptured.Percent(minStrongHoldsCaptured, maxStrongHoldsCaptured);
                    p.StrongholdSecurePercent  = p.StrongholdsSecured.Percent(minStrongholdsSecured, maxStrongholdsSecured);
                    p.StrongholdDefendPercent  = p.StrongholdsDefended.Percent(minStrongholdsDefended, maxStrongholdsDefended);

                    p.ScorePercent          = p.Score.Percent(minScore, maxScore);
                    p.KillsPercent          = p.Kills.Percent(minKills, maxKills);
                    p.RoundsSurvivedPercent = p.RoundsSurvived.Percent(minRoundsSurvived, maxRoundsSurvived);
                    p.RoundsCompletePercent = p.RoundsComplete.Percent(minRoundsComplete, maxRoundsComplete);
                    p.BossTakedownsPercent  = p.BossTakedowns.Percent(minBossTakedowns, maxBossTakedowns);

                    p.TotalSpartanKillPercent = p.TotalSpartanKills.Percent(minTotalSpartanKills, maxTotalSpartanKills);
                    p.NpcKillPercent          = p.NpcKills.Percent(minNpcKills, maxNpcKills);
                }

                result.Teams.Add(team);
            }

            var player      = players.FirstOrDefault(p => p.GamerTag.ToUpper() == gamerTag.ToUpper());
            var playersTeam = result.Teams.FirstOrDefault(t => t.TeamId == player?.TeamId);

            if (playersTeam != null && player != null)
            {
                player.IsPlayer = true;
                if (player.DNF)
                {
                    result.Result = Enumeration.ResultType.DidNotFinish;
                }
                else if (playersTeam.Rank == 1)
                {
                    result.Result = result.Teams.Any(t => t.TeamId != playersTeam.TeamId && t.Rank == 0) ? Enumeration.ResultType.Tied : Enumeration.ResultType.Won;
                }
                else
                {
                    result.Result = Enumeration.ResultType.Lost;
                }
                result.PlayerTeamColor = playersTeam.TeamColor;
            }
        }