Move timing distribution graph to osu.Game

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

@@ -0,0 +1,159 @@
+// 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.
+
+using System;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Scoring;
+
+namespace osu.Game.Screens.Ranking.Statistics
+{
+    public class HitEventTimingDistributionGraph : CompositeDrawable
+    {
+        /// <summary>
+        /// The number of bins on each side of the timing distribution.
+        /// </summary>
+        private const int timing_distribution_bins = 50;
+
+        /// <summary>
+        /// The total number of bins in the timing distribution, including bins on both sides and the centre bin at 0.
+        /// </summary>
+        private const int total_timing_distribution_bins = timing_distribution_bins * 2 + 1;
+
+        /// <summary>
+        /// The centre bin, with a timing distribution very close to/at 0.
+        /// </summary>
+        private const int timing_distribution_centre_bin_index = timing_distribution_bins;
+
+        /// <summary>
+        /// The number of data points shown on the axis below the graph.
+        /// </summary>
+        private const float axis_points = 5;
+
+        private readonly ScoreInfo score;
+
+        public HitEventTimingDistributionGraph(ScoreInfo score)
+        {
+            this.score = score;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            if (score.HitEvents == null || score.HitEvents.Count == 0)
+                return;
+
+            int[] bins = new int[total_timing_distribution_bins];
+            double binSize = score.HitEvents.Max(e => Math.Abs(e.TimeOffset)) / timing_distribution_bins;
+
+            foreach (var e in score.HitEvents)
+            {
+                int binOffset = (int)(e.TimeOffset / binSize);
+                bins[timing_distribution_centre_bin_index + binOffset]++;
+            }
+
+            int maxCount = bins.Max();
+            var bars = new Drawable[total_timing_distribution_bins];
+            for (int i = 0; i < bars.Length; i++)
+                bars[i] = new Bar { Height = (float)bins[i] / maxCount };
+
+            Container axisFlow;
+
+            InternalChild = new GridContainer
+            {
+                RelativeSizeAxes = Axes.Both,
+                Width = 0.8f,
+                Content = new[]
+                {
+                    new Drawable[]
+                    {
+                        new GridContainer
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Content = new[] { bars }
+                        }
+                    },
+                    new Drawable[]
+                    {
+                        axisFlow = new Container
+                        {
+                            RelativeSizeAxes = Axes.X,
+                            AutoSizeAxes = Axes.Y
+                        }
+                    },
+                },
+                RowDimensions = new[]
+                {
+                    new Dimension(),
+                    new Dimension(GridSizeMode.AutoSize),
+                }
+            };
+
+            // Our axis will contain one centre element + 5 points on each side, each with a value depending on the number of bins * bin size.
+            double maxValue = timing_distribution_bins * binSize;
+            double axisValueStep = maxValue / axis_points;
+
+            axisFlow.Add(new OsuSpriteText
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Text = "0",
+                Font = OsuFont.GetFont(size: 12, weight: FontWeight.SemiBold)
+            });
+
+            for (int i = 1; i <= axis_points; i++)
+            {
+                double axisValue = i * axisValueStep;
+                float position = (float)(axisValue / maxValue);
+                float alpha = 1f - position * 0.8f;
+
+                axisFlow.Add(new OsuSpriteText
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativePositionAxes = Axes.X,
+                    X = -position / 2,
+                    Alpha = alpha,
+                    Text = axisValue.ToString("-0"),
+                    Font = OsuFont.GetFont(size: 12, weight: FontWeight.SemiBold)
+                });
+
+                axisFlow.Add(new OsuSpriteText
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativePositionAxes = Axes.X,
+                    X = position / 2,
+                    Alpha = alpha,
+                    Text = axisValue.ToString("+0"),
+                    Font = OsuFont.GetFont(size: 12, weight: FontWeight.SemiBold)
+                });
+            }
+        }
+
+        private class Bar : CompositeDrawable
+        {
+            public Bar()
+            {
+                Anchor = Anchor.BottomCentre;
+                Origin = Anchor.BottomCentre;
+
+                RelativeSizeAxes = Axes.Both;
+
+                Padding = new MarginPadding { Horizontal = 1 };
+
+                InternalChild = new Circle
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = Color4Extensions.FromHex("#66FFCC")
+                };
+            }
+        }
+    }
+}