Option: show room success rate colors in chapter graph (#140)

* Success rate colors in graph (no way to turn off)

* Use success rate rather than golden success rate

* Use default colors

* Use same successRate as `{room:successRate}` format

* Add setting toggle for showing success rate colors in graph

* Move room success rate calculation used by graph overlay
to `SuccessRateStat`

* Cache success rate data for graph overlay
Also, adjust `ChokeRateStat` caching code to match

All caches are invalidated on run end or chapter change.
`SuccessRateStat` cache is also invaludated in:
- `RoomStats.AddAttempt`
- `RoomStats.RemoveLastAttempt`

* Reset stat cache in `Events.OnAfterSavingStats`

* Dim success rate colors in graph overlay for past rooms
when using standard room indicator

* Chapter graph success rate colors flashing with non-explicit indicator

* Change graph overlay color switching to use sinosoidal animation

* Update variable name to match code style

* GraphOverlay blink to darker colors

* Graph overlay start blinking animation at same brightness level
as is currently being shown

Author: NonbinaryCoder

ConsistencyTracker.cs

@@ -858,7 +858,7 @@ private void EventsOnRunStarted() {
         }
 
         private void EventsOnRunEnded(bool died, bool won) {
-            ChokeRateStat.ChokeRateData = null; //Reset caching
+            StatManager.InvalidateCachedStats();
             IngameOverlay?.SetGoldenState(false);
         }
         private void Events_OnChangedRoom(string roomName, bool isPreviousRoom) {
@@ -930,8 +930,8 @@ private void ChangeChapter(Session session) {
             //fix for SpeedrunTool savestate inconsistency
             TouchedBerries.Clear();
 
-            //Reset caching of choke rate data
-            ChokeRateStat.ChokeRateData = null;
+            //Reset caching
+            StatManager.InvalidateCachedStats();
 
             //Cause initial stats calculation
             SetNewRoom(CurrentRoomName, false);
@@ -1603,7 +1603,7 @@ public void RemoveRoomGoldenBerryDeaths(bool removeOne = false) {
             }
 
             //Reset cached choke rate data for graph
-            ChokeRateStat.ChokeRateData = null;
+            ChokeRateStat.InvalidateCache();
             SaveChapterStats();
         }
         public void WipeChapterGoldenBerryDeaths() {

ConsistencyTrackerSettings.cs

@@ -1175,6 +1175,9 @@ public void CreateExternalOverlayEntry(TextMenu menu, bool inGame) {
         [SettingIgnore]
         public bool IngameOverlayGraphShowGoldenPbBar { get; set; } = true;
 
+        [SettingIgnore]
+        public bool IngameOverlayGraphShowSuccessRateColors { get; set; } = false;
+        
         [SettingIgnore]
         public bool IngameOverlayGraphCurrentRoomExplicit { get; set; } = true;
 
@@ -1434,6 +1437,13 @@ public void CreateIngameOverlayEntry(TextMenu menu, bool inGame) {
                 }
             });
             subMenu.AddDescription(menu, menuItem, "Shows your PB room as a golden bar at the bottom of the graph.");
+
+            subMenu.Add(menuItem = new TextMenu.OnOff("Graph Show Success Rate Colors", IngameOverlayGraphShowSuccessRateColors) {
+                OnValueChange = v => {
+                    IngameOverlayGraphShowSuccessRateColors = v;
+                }
+            });
+            subMenu.AddDescription(menu, menuItem, "Colors bars in graph to match room success rate color.");
 
             subMenu.Add(menuItem = new TextMenu.OnOff("Graph Current Room Indicator Explicit", IngameOverlayGraphCurrentRoomExplicit) {
                 OnValueChange = v => {

Entities/GraphOverlay.cs

@@ -14,6 +14,14 @@ public class GraphOverlay : Entity {
         private static readonly int WIDTH = 1920;
         private static readonly int HEIGHT = 1080;
 
+        // red, yellow, green, lightgreen
+        private static readonly Color[] SUCCESS_RATE_COLORS = {
+            Color.Red, Color.Yellow, Color.Green, Color.LightGreen, // STANDARD
+            new Color(105, 0, 0), new Color(100, 99, 0), new Color(0, 47, 0), new Color(0, 101, 0), // VISITED
+        };
+        private static int roomLastFrame = 0;
+        private static float blinkT = 0.0f;
+
         private static ConsistencyTrackerModule Mod => ConsistencyTrackerModule.Instance;
 
         private static bool Enabled => Mod.ModSettings.IngameOverlayGraphEnabled;
@@ -29,6 +37,7 @@ public class GraphOverlay : Entity {
         private static int BackgroundDim => Mod.ModSettings.IngameOverlayGraphBackgroundDim;
 
         private Dictionary<RoomInfo, Tuple<int, float, int, float>> ChokeRateData { get; set; }
+        private Dictionary<RoomInfo, float> SuccessRateData { get; set; }
         private int HighestDifficulty { get; set; }
         private RoomInfo PbRoom { get; set; }
         private RoomInfo PbRoomSession { get; set; }
@@ -43,6 +52,7 @@ public GraphOverlay() {
         }
 
         private void EventsOnAfterSavingStats() {
+            StatManager.InvalidateCachedStats();
             UpdateOverlay();
         }
 
@@ -55,6 +65,7 @@ public void UpdateOverlay() {
             if (path == null || stats == null) return;
 
             ChokeRateData = ChokeRateStat.GetRoomData(path, stats);
+            SuccessRateData = SuccessRateStat.GetRoomData(path, stats);
             PbRoom = StatsUtil.GetFurthestGoldenRun(path, stats);
             PbRoomSession = StatsUtil.GetFurthestGoldenRunSession(path, stats);
 
@@ -121,6 +132,8 @@ public override void Render() {
             int availableBarHeight = Height - (ShowGoldenPbBar ? 3 + 1 : 0) - (currentRoomIndicatorExplicit ? 3 + 1 : 0);
             int barWidth = (availableBarWidth - ((barCount - 1) * BarSpacing)) / barCount;
             int paddingX = (availableBarWidth - (barWidth * barCount) - ((barCount - 1) * BarSpacing)) / 2;
+
+            bool showSuccessRateColors = Mod.ModSettings.IngameOverlayGraphShowSuccessRateColors;
 
             //Walk path and draw the bars
             int barsDrawn = 0;
@@ -152,6 +165,54 @@ public override void Render() {
                     if (!visitedCurrent) {
                         barColor = Color.Gray;
                     }
+                    bool isCurrentRoom = currentRoom != null && rInfo.RoomNumberInChapter == currentRoom.RoomNumberInChapter;
+
+                    //Color code for success rate display
+                    if (showSuccessRateColors) {
+                        barHeight = Math.Max(3, barHeight);
+
+                        if (SuccessRateData.ContainsKey(rInfo)) {
+                            float successRate = SuccessRateData[rInfo];
+                            if (float.IsNaN(successRate)) {
+                                barColor = Color.Gray;
+                            } else {
+                                int colorIndex;
+                                if (successRate > ((float)Mod.ModSettings.LiveDataChapterBarLightGreenPercent / 100 - 0.001)) {
+                                    colorIndex = 3;
+                                } else if (successRate > ((float)Mod.ModSettings.LiveDataChapterBarGreenPercent / 100 - 0.001)) {
+                                    colorIndex = 2;
+                                } else if (successRate > ((float)Mod.ModSettings.LiveDataChapterBarYellowPercent / 100 - 0.001)) {
+                                    colorIndex = 1;
+                                } else {
+                                    colorIndex = 0;
+                                }
+
+                                if (currentRoomIndicatorExplicit) {
+                                    barColor = SUCCESS_RATE_COLORS[colorIndex];
+                                } else {
+                                    if (isCurrentRoom) {
+                                        // Current room; blink
+                                        blinkT += Engine.RawDeltaTime * 3.1415f;
+                                        if (roomLastFrame < rInfo.RoomNumberInChapter) {
+                                            // Went backwards.
+                                            blinkT = 0.0f;
+                                        } else if (roomLastFrame > rInfo.RoomNumberInChapter) {
+                                            // Went forwards.
+                                            blinkT = 3.1415f;
+                                        }
+                                        float t = ((float) Math.Cos(blinkT)) * 0.5f + 0.5f;
+                                        var baseColor = SUCCESS_RATE_COLORS[colorIndex];
+                                        var brightColor = SUCCESS_RATE_COLORS[colorIndex + 4];
+                                        barColor = Util.LerpColors(brightColor, baseColor, t);
+                                        roomLastFrame = rInfo.RoomNumberInChapter;
+                                    } else {
+                                        barColor = SUCCESS_RATE_COLORS[colorIndex + (visitedCurrent ? 0 : 4)];
+                                    }
+                                }
+                            }
+
+                        }
+                    }
 
                     //Draw checkpoint indicator over the empty space before this bar
                     if (!isFirstCheckpoint && rInfo.RoomNumberInCP == 1 && Mod.ModSettings.IngameOverlayGraphShowCheckpointIndicator) {
@@ -195,7 +256,7 @@ public override void Render() {
                     }
 
                     //Current room indicator
-                    if (currentRoom != null && rInfo.RoomNumberInChapter == currentRoom.RoomNumberInChapter && currentRoomIndicatorExplicit) {
+                    if (isCurrentRoom && currentRoomIndicatorExplicit) {
                         int heightOffset = ShowGoldenPbBar ? 3 + 1 : 0;
                         Draw.Rect(paddingX + position.X + (barWidth * barsDrawn) + (BarSpacing * barsDrawn) + beforeBarsOffset, 
                                   position.Y + availableBarHeight + heightOffset + 1,
@@ -286,4 +347,4 @@ private static Vector2 ResolvePosition(StatTextPosition pos, int width, int heig
             return position;
         }
     }
-}
+}

Models/ChapterStats.cs

@@ -745,13 +745,17 @@ public void AddAttempt(bool success) {
             }
 
             PreviousAttempts.Add(success);
+
+            SuccessRateStat.InvalidateCache();
         }
 
         public void RemoveLastAttempt() {
             if (PreviousAttempts.Count <= 0) {
                 return;
             }
             PreviousAttempts.RemoveAt(PreviousAttempts.Count-1);
+
+            SuccessRateStat.InvalidateCache();
         }
 
         public long GetTimeForCategory(TimeCategory category) {

Stats/ChokeRateStat.cs

@@ -265,7 +265,7 @@ public override string FormatSummary(PathInfo chapterPath, ChapterStats chapterS
             return null;
         }
 
-        public static Dictionary<RoomInfo, Tuple<int, float, int, float>> ChokeRateData { get; set; } = null;
+        private static Dictionary<RoomInfo, Tuple<int, float, int, float>> ChokeRateData = null;
         /// <summary>
         /// Gets the following data for every room: Golden Entries, Golden Success Rate, Golden Entries Session, Golden Success Rate Session
         /// </summary>
@@ -320,6 +320,12 @@ public static Dictionary<RoomInfo, Tuple<int, float, int, float>> GetRoomData(Pa
             ChokeRateData = roomData;
             return roomData;
         }
+        /// <summary>
+        /// Deletes cached room choke rate data, resulting in it being recomputed next time it is requested.
+        /// </summary>
+        public static void InvalidateCache() {
+            ChokeRateData = null;
+        }
 
         /// <summary>
         /// Gets the following data for every room: Golden Entries Session, Golden Success Rate Session

Stats/StatManager.cs

@@ -419,6 +419,15 @@ public bool DeleteFormat(string formatName) {
             Mod.SaveChapterStats();
             return true;
         }
+
+        /// <summary>
+        /// Resets the caches used by stats shown in the graph overlay.
+        /// Currently, resets cache for `ChokeRateStat` and `SuccessRateStat`.
+        /// </summary>
+        public static void InvalidateCachedStats() {
+            ChokeRateStat.InvalidateCache();
+            SuccessRateStat.InvalidateCache();
+        }
         #endregion
 
         #region Format file IO

Stats/SuccessRateStat.cs

@@ -80,6 +80,34 @@ public override string FormatSummary(PathInfo chapterPath, ChapterStats chapterS
             return null;
         }
 
+        private static Dictionary<RoomInfo, float> SuccessRateData = null;
+        /// <summary>
+        /// Gets the success rate data (based on fraction of successes in latest `StatManager.AttemptCount` attempts) for each room.
+        /// </summary>
+        public static Dictionary<RoomInfo, float> GetRoomData(PathInfo chapterPath, ChapterStats chapterStats) {
+            if (SuccessRateData != null) return SuccessRateData;
+
+            int attemptCount = StatManager.AttemptCount;
+            var roomData = new Dictionary<RoomInfo, float>();
+
+            foreach (CheckpointInfo cpInfo in chapterPath.Checkpoints) {
+                foreach (RoomInfo rInfo in cpInfo.Rooms) {
+                    RoomStats data = chapterStats.GetRoom(rInfo);
+                    float successRate = data.AverageSuccessOverN(attemptCount);
+                    roomData.Add(rInfo, successRate);
+                }
+            }
+
+            SuccessRateData = roomData;
+            return roomData;
+        }
+        /// <summary>
+        /// Deletes cached room success rate data, resulting in it being recomputed next time it is requested.
+        /// </summary>
+        public static void InvalidateCache() {
+            SuccessRateData = null;
+        }
+
 
         //success-rate;Room SR: {room:successRate} | CP: {checkpoint:successRate} | Total: {chapter:successRate}
         public override List<KeyValuePair<string, string>> GetPlaceholderExplanations() {

Utility/Util.cs

@@ -189,5 +189,10 @@ public static string ColorToHex(Color color) {
             return $"#{color.R:X2}{color.G:X2}{color.B:X2}";
         }
 
+        public static Color LerpColors(Color a, Color b, float t) {
+            float am = 1.0f - t;
+            return new Color((int) (a.R * am + b.R * t), (int) (a.G * am + b.G * t), (int) (a.B * am + b.B * t), (int) (a.A * am + b.A * t));
+        }
+
     }
-}
+}