Merge pull request #20248 from acid-chicken/fix/stats/td

Fix new hit distribution graph didn't account for size changes

osu.Game.Tests/Visual/Ranking/TestSceneHitEventTimingDistributionGraph.cs

@@ -5,6 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
+using osu.Framework.Bindables;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Shapes;
@@ -19,14 +20,24 @@ namespace osu.Game.Tests.Visual.Ranking
     public class TestSceneHitEventTimingDistributionGraph : OsuTestScene
     {
         private HitEventTimingDistributionGraph graph = null!;
+        private readonly BindableFloat width = new BindableFloat(600);
+        private readonly BindableFloat height = new BindableFloat(130);
 
         private static readonly HitObject placeholder_object = new HitCircle();
 
+        public TestSceneHitEventTimingDistributionGraph()
+        {
+            width.BindValueChanged(e => graph.Width = e.NewValue);
+            height.BindValueChanged(e => graph.Height = e.NewValue);
+        }
+
         [Test]
         public void TestManyDistributedEvents()
         {
             createTest(CreateDistributedHitEvents());
             AddStep("add adjustment", () => graph.UpdateOffset(10));
+            AddSliderStep("width", 0.0f, 1000.0f, width.Value, width.Set);
+            AddSliderStep("height", 0.0f, 1000.0f, height.Value, height.Set);
         }
 
         [Test]
@@ -137,7 +148,7 @@ namespace osu.Game.Tests.Visual.Ranking
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
-                    Size = new Vector2(600, 130)
+                    Size = new Vector2(width.Value, height.Value)
                 }
             };
         });

osu.Game/Screens/Ranking/Statistics/HitEventTimingDistributionGraph.cs

@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-#nullable disable
-
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -47,6 +45,12 @@ namespace osu.Game.Screens.Ranking.Statistics
         /// </summary>
         private readonly IReadOnlyList<HitEvent> hitEvents;
 
+        private readonly IDictionary<HitResult, int>[] bins;
+        private double binSize;
+        private double hitOffset;
+
+        private Bar[]? barDrawables;
+
         /// <summary>
         /// Creates a new <see cref="HitEventTimingDistributionGraph"/>.
         /// </summary>
@@ -54,22 +58,15 @@ namespace osu.Game.Screens.Ranking.Statistics
         public HitEventTimingDistributionGraph(IReadOnlyList<HitEvent> hitEvents)
         {
             this.hitEvents = hitEvents.Where(e => !(e.HitObject.HitWindows is HitWindows.EmptyHitWindows) && e.Result.IsHit()).ToList();
+            bins = Enumerable.Range(0, total_timing_distribution_bins).Select(_ => new Dictionary<HitResult, int>()).ToArray<IDictionary<HitResult, int>>();
         }
 
-        private IDictionary<HitResult, int>[] bins;
-        private double binSize;
-        private double hitOffset;
-
-        private Bar[] barDrawables;
-
         [BackgroundDependencyLoader]
         private void load()
         {
-            if (hitEvents == null || hitEvents.Count == 0)
+            if (hitEvents.Count == 0)
                 return;
 
-            bins = Enumerable.Range(0, total_timing_distribution_bins).Select(_ => new Dictionary<HitResult, int>()).ToArray<IDictionary<HitResult, int>>();
-
             binSize = Math.Ceiling(hitEvents.Max(e => Math.Abs(e.TimeOffset)) / timing_distribution_bins);
 
             // Prevent div-by-0 by enforcing a minimum bin size
@@ -209,25 +206,30 @@ namespace osu.Game.Screens.Ranking.Statistics
 
         private class Bar : CompositeDrawable
         {
-            private float totalValue => values.Sum(v => v.Value);
-            private float basalHeight => BoundingBox.Width / BoundingBox.Height;
-            private float availableHeight => 1 - basalHeight;
-
             private readonly IReadOnlyList<KeyValuePair<HitResult, int>> values;
             private readonly float maxValue;
             private readonly bool isCentre;
+            private readonly float totalValue;
 
-            private Circle[] boxOriginals;
+            private float basalHeight;
-            private Circle boxAdjustment;
+            private float offsetAdjustment;
+
+            private Circle[] boxOriginals = null!;
+
+            private Circle? boxAdjustment;
 
             [Resolved]
-            private OsuColour colours { get; set; }
+            private OsuColour colours { get; set; } = null!;
+
+            private const double duration = 300;
 
             public Bar(IDictionary<HitResult, int> values, float maxValue, bool isCentre)
             {
                 this.values = values.OrderBy(v => v.Key.GetIndexForOrderedDisplay()).ToList();
                 this.maxValue = maxValue;
                 this.isCentre = isCentre;
+                totalValue = values.Sum(v => v.Value);
+                offsetAdjustment = totalValue;
 
                 RelativeSizeAxes = Axes.Both;
                 Masking = true;
@@ -254,38 +256,32 @@ namespace osu.Game.Screens.Ranking.Statistics
                 else
                 {
                     // A bin with no value draws a grey dot instead.
-                    InternalChildren = boxOriginals = new[]
+                    Circle dot = new Circle
-                    {
-                        new Circle
                     {
                         RelativeSizeAxes = Axes.Both,
                         Anchor = Anchor.BottomCentre,
                         Origin = Anchor.BottomCentre,
                         Colour = isCentre ? Color4.White : Color4.Gray,
                         Height = 0,
-                        },
                     };
+                    InternalChildren = boxOriginals = new[] { dot };
                 }
             }
 
-            private const double duration = 300;
-
-            private float offsetForValue(float value)
-            {
-                return availableHeight * value / maxValue;
-            }
-
-            private float heightForValue(float value)
-            {
-                return basalHeight + offsetForValue(value);
-            }
-
             protected override void LoadComplete()
             {
                 base.LoadComplete();
 
+                if (!values.Any())
+                    return;
+
+                updateBasalHeight();
+
                 foreach (var boxOriginal in boxOriginals)
+                {
+                    boxOriginal.Y = 0;
                     boxOriginal.Height = basalHeight;
+                }
 
                 float offsetValue = 0;
 
@@ -297,6 +293,12 @@ namespace osu.Game.Screens.Ranking.Statistics
                 }
             }
 
+            protected override void Update()
+            {
+                base.Update();
+                updateBasalHeight();
+            }
+
             public void UpdateOffset(float adjustment)
             {
                 bool hasAdjustment = adjustment != totalValue;
@@ -318,7 +320,53 @@ namespace osu.Game.Screens.Ranking.Statistics
                     });
                 }
 
-                boxAdjustment.ResizeHeightTo(heightForValue(adjustment), duration, Easing.OutQuint);
+                offsetAdjustment = adjustment;
+                drawAdjustmentBar();
+            }
+
+            private void updateBasalHeight()
+            {
+                float newBasalHeight = DrawHeight > DrawWidth ? DrawWidth / DrawHeight : 1;
+
+                if (newBasalHeight == basalHeight)
+                    return;
+
+                basalHeight = newBasalHeight;
+                foreach (var dot in boxOriginals)
+                    dot.Height = basalHeight;
+
+                draw();
+            }
+
+            private float offsetForValue(float value) => (1 - basalHeight) * value / maxValue;
+
+            private float heightForValue(float value) => MathF.Max(basalHeight + offsetForValue(value), 0);
+
+            private void draw()
+            {
+                resizeBars();
+
+                if (boxAdjustment != null)
+                    drawAdjustmentBar();
+            }
+
+            private void resizeBars()
+            {
+                float offsetValue = 0;
+
+                for (int i = 0; i < values.Count; i++)
+                {
+                    boxOriginals[i].Y = offsetForValue(offsetValue) * DrawHeight;
+                    boxOriginals[i].Height = heightForValue(values[i].Value);
+                    offsetValue -= values[i].Value;
+                }
+            }
+
+            private void drawAdjustmentBar()
+            {
+                bool hasAdjustment = offsetAdjustment != totalValue;
+
+                boxAdjustment.ResizeHeightTo(heightForValue(offsetAdjustment), duration, Easing.OutQuint);
                 boxAdjustment.FadeTo(!hasAdjustment ? 0 : 1, duration, Easing.OutQuint);
             }
         }