reapply old whr fixes for debugging

Author: DeinFreund

Autoregistrator/Resources/campaignMaps.txt

@@ -53,7 +53,6 @@ SailAway
 SiberianDivide 1.1
 StormSiege_v3
 Downs_of_Destruction_Fix
-Melt_V2
 Craterv01
 SapphireShores_Dry_V2.2
 Valiant_Saltscape
@@ -69,3 +68,4 @@ La Isla Bonita v1.1
 Living Lands 4.1
 Obsidian_1.5
 Rogues River v1.2
+Conquest_of_Paradise_v1

ZkData/Ef/WHR/WholeHistoryRating.cs

@@ -467,15 +467,19 @@ public string DebugPlayer(Account player)
         //Runs in O(N log(N)) for all players
         private void UpdateRankings(IEnumerable<Player> players)
         {
+            Dictionary<int, float> oldRatings = new Dictionary<int, float>();
+            List<SpringBattlePlayer> lastBattlePlayers;
+            var debriefings = new Dictionary<int, PendingDebriefing>(pendingDebriefings);
+            int matched = 0;
+
             try
             {
-                Dictionary<int, float> oldRatings = new Dictionary<int, float>();
-
+             
                 //check for ladder elo updates
                 using (var db = new ZkDataContext())
                 {
-                    var battleIDs = pendingDebriefings.Keys.ToList();
-                    var lastBattlePlayers = db.SpringBattlePlayers.Where(p => battleIDs.Contains(p.SpringBattleID) && !p.IsSpectator).Include(x => x.Account).DistinctBy(x => x.AccountID).ToList();
+                    var battleIDs = debriefings.Keys.ToList();
+                    lastBattlePlayers = db.SpringBattlePlayers.Where(p => battleIDs.Contains(p.SpringBattleID) && !p.IsSpectator).Include(x => x.Account).DistinctBy(x => x.AccountID).ToList();
                     oldRatings = lastBattlePlayers.ToDictionary(p => (p.AccountID), p => GetPlayerRating(p.AccountID).LadderElo);
                     lastBattlePlayers.Where(p => !playerRatings.ContainsKey((p.AccountID))).ForEach(p => playerRatings[(p.AccountID)] = new PlayerRating(DefaultRating));
                     lastBattlePlayers.ForEach(p => playerRatings[(p.AccountID)].LadderElo = Ranks.UpdateLadderRating(p.Account, category, getPlayerById((p.AccountID)).avgElo + RatingOffset, p.IsInVictoryTeam, !p.IsInVictoryTeam, db));
@@ -512,7 +516,6 @@ private void UpdateRankings(IEnumerable<Player> players)
                 this.activePlayers = playerCount;
                 int rank = 0;
                 List<int> newTopPlayers = new List<int>();
-                int matched = 0;
                 List<float> newPercentileBrackets = new List<float>();
                 newPercentileBrackets.Add(playerRatings[sortedPlayers.First().Value].LadderElo);
                 float percentile;
@@ -552,37 +555,46 @@ private void UpdateRankings(IEnumerable<Player> players)
 
                 //check for rank updates
 
-                if (pendingDebriefings.Any())
+                
+            }
+            catch (Exception ex)
+            {
+                Trace.TraceError("WHR " + category + ": Failed to update rankings: " + ex);
+                return;
+            }
+            try
+            {
+                if (debriefings.Any())
                 {
                     List<int> playersWithRatingChange = new List<int>();
                     Dictionary<int, int> oldRanks = new Dictionary<int, int>();
                     Dictionary<int, Account> updatedRanks = new Dictionary<int, Account>();
                     Dictionary<int, Account> involvedAccounts = new Dictionary<int, Account>();
-                    Trace.TraceInformation("WHR Filling in Debriefings for Battles: " + pendingDebriefings.Keys.Select(x => "B" + x).StringJoin());
+                    Trace.TraceInformation("WHR Filling in Debriefings for Battles: " + debriefings.Keys.Select(x => "B" + x).StringJoin());
                     using (var db = new ZkDataContext())
                     {
-                        var battleIDs = pendingDebriefings.Keys.ToList();
-                        var lastBattlePlayers = db.SpringBattlePlayers.Where(p => battleIDs.Contains(p.SpringBattleID) && !p.IsSpectator).Include(x => x.Account).ToList();
                         involvedAccounts = lastBattlePlayers.ToDictionary(p => p.AccountID, p => p.Account);
                         Trace.TraceInformation("WHR Debriefing players: " + involvedAccounts.Values.Select(x => x.Name).StringJoin());
                         oldRanks = lastBattlePlayers.ToDictionary(p => p.AccountID, p => p.Account.Rank);
                         updatedRanks = lastBattlePlayers.Where(p => Ranks.UpdateRank(p.Account, p.IsInVictoryTeam, !p.IsInVictoryTeam, db)).Select(x => x.Account).ToDictionary(p => p.AccountID, p => p);
                         updatedRanks.Values.ForEach(p => db.Entry(p).State = EntityState.Modified);
                         playersWithRatingChange = lastBattlePlayers.Select(x => x.AccountID).ToList();
 
-                        lastBattlePlayers.Where(p => playerOldRatings.ContainsKey((p.AccountID)) && !p.EloChange.HasValue).ForEach(p =>
+                        lastBattlePlayers.Where(p => /*playerOldRatings.ContainsKey((p.AccountID)) && */ !p.EloChange.HasValue).ForEach(p =>
                         {
                             //p.EloChange = playerRatings[(p.AccountID)].RealElo - playerOldRatings[(p.AccountID)].RealElo;
                             p.EloChange = playerRatings[(p.AccountID)].LadderElo - oldRatings[(p.AccountID)];
+                            db.Entry(p).State = EntityState.Modified;
                         });
 
-                        db.SpringBattlePlayers.Where(p => battleIDs.Contains(p.SpringBattleID) && !p.IsSpectator).ToList().ForEach(x => playerOldRatings[(x.AccountID)] = playerRatings[(x.AccountID)]);
+                        lastBattlePlayers.ForEach(x => playerOldRatings[x.AccountID] = playerRatings[x.AccountID]);
                         db.SaveChanges();
                     }
                     //Publish new results only after saving new stats to db.
-                    pendingDebriefings.ForEach(pair =>
+                    debriefings.ForEach(pair =>
                     {
-                        pair.Value.partialDebriefing.DebriefingUsers.Values.ForEach(user => {
+                        pair.Value.partialDebriefing.DebriefingUsers.Values.ForEach(user =>
+                        {
                             try
                             {
                                 user.EloChange = playerRatings[(user.AccountID)].LadderElo - oldRatings[(user.AccountID)];
@@ -594,7 +606,7 @@ private void UpdateRankings(IEnumerable<Player> players)
                                 user.PrevRankElo = prog.RankFloorElo;
                                 user.NewElo = prog.CurrentElo;
                             }
-                            catch(Exception ex)
+                            catch (Exception ex)
                             {
                                 Trace.TraceError("Unable to complete debriefing for user " + user.AccountID + ": " + ex);
                             }
@@ -603,9 +615,9 @@ private void UpdateRankings(IEnumerable<Player> players)
                         pair.Value.debriefingConsumer.Invoke(pair.Value.partialDebriefing);
                     });
                     RatingsUpdated(this, new RatingUpdate() { affectedPlayers = playersWithRatingChange });
-                    pendingDebriefings.Clear();
+                    debriefings.ForEach(x => pendingDebriefings.TryRemove(x.Key, out _));
+
                 }
-                
 
                 //check for topX updates
                 GetTopPlayers(GlobalConst.LadderSize);
@@ -620,12 +632,7 @@ private void UpdateRankings(IEnumerable<Player> players)
             }
             catch (Exception ex)
             {
-                string dbg = "WHR " + category + ": Failed to update rankings " + ex + "\nPlayers: ";
-                foreach (var p in players)
-                {
-                    dbg += p.id + " (" + p.days.Count + " days), ";
-                }
-                Trace.TraceError(dbg);
+                Trace.TraceError("WHR " + category + ": Failed to process battles for rankings: " + ex);
             }
         }