Make slider parsing kind of exist.

osu.Desktop.VisualTests/Tests/TestCasePlayer.cs

@@ -10,9 +10,11 @@ using osu.Game.Beatmaps.Formats;
 using OpenTK;
 using osu.Framework;
 using osu.Framework.Allocation;
+using osu.Framework.Graphics.Sprites;
 using osu.Game.Modes.Objects;
 using osu.Game.Modes.Osu.Objects;
 using osu.Game.Screens.Play;
+using OpenTK.Graphics;
 
 namespace osu.Desktop.VisualTests.Tests
 {
@@ -41,7 +43,8 @@ namespace osu.Desktop.VisualTests.Tests
                 objects.Add(new HitCircle()
                 {
                     StartTime = time,
-                    Position = new Vector2(RNG.Next(0, 512), RNG.Next(0, 384)),
+                    Position = new Vector2(i % 4 == 0 || i % 4 == 2 ? 0 : 512, 
+                    i % 4 < 2 ? 0 : 384),
                     NewCombo = i % 4 == 0
                 });
 
@@ -57,6 +60,12 @@ namespace osu.Desktop.VisualTests.Tests
 
             decoder.Process(b);
 
+            Add(new Box
+            {
+                RelativeSizeAxes = Framework.Graphics.Axes.Both,
+                Colour = Color4.Gray,
+            });
+
             Add(new Player
             {
                 Beatmap = new WorkingBeatmap(b)

osu.Game.Mode.Osu/Objects/Drawables/DrawableHitCircle.cs

@@ -30,8 +30,7 @@ namespace osu.Game.Modes.Osu.Objects.Drawables
             this.h = h;
 
             Origin = Anchor.Centre;
-            RelativePositionAxes = Axes.Both;
+            Position = h.Position;
-            Position = new Vector2(h.Position.X / 512, h.Position.Y / 384);
 
             Children = new Drawable[]
             {

osu.Game.Mode.Osu/Objects/Drawables/DrawableSlider.cs

@@ -1,4 +1,9 @@
-using osu.Game.Modes.Objects.Drawables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Modes.Objects.Drawables;
+using osu.Game.Modes.Osu.Objects.Drawables.Pieces;
+using OpenTK;
+using OpenTK.Graphics;
 
 namespace osu.Game.Modes.Osu.Objects.Drawables
 {
@@ -6,12 +11,42 @@ namespace osu.Game.Modes.Osu.Objects.Drawables
     {
         public DrawableSlider(Slider h) : base(h)
         {
+            Origin = Anchor.Centre;
+            RelativePositionAxes = Axes.Both;
+            Position = new Vector2(h.Position.X / 512, h.Position.Y / 384);
 
+            for (float i = 0; i <= 1; i += 0.1f)
+            {
+                Add(new CirclePiece
+                {
+                    Colour = h.Colour,
+                    Hit = Hit,
+                    Position = h.Curve.PositionAt(i) - h.Position //non-relative?
+                });
+            }
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            //force application of the state that was set before we loaded.
+            UpdateState(State);
         }
 
         protected override void UpdateState(ArmedState state)
         {
+            if (!IsLoaded) return;
 
+            Flush(true); //move to DrawableHitObject
+
+            Alpha = 0;
+
+            Delay(HitObject.StartTime - 200 - Time.Current, true);
+
+            FadeIn(200);
+            Delay(200 + HitObject.Duration);
+            FadeOut(200);
         }
     }
 }

osu.Game.Mode.Osu/Objects/OsuHitObjectParser.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
@@ -25,7 +26,68 @@ namespace osu.Game.Modes.Osu.Objects
                     result = new HitCircle();
                     break;
                 case OsuBaseHit.HitObjectType.Slider:
-                    result = new Slider();
+                    Slider s = new Slider();
+
+                    CurveTypes curveType = CurveTypes.Catmull;
+                    int repeatCount = 0;
+                    double length = 0;
+                    List<Vector2> points = new List<Vector2>();
+
+                    points.Add(new Vector2(int.Parse(split[0]), int.Parse(split[1])));
+
+                    string[] pointsplit = split[5].Split('|');
+                    for (int i = 0; i < pointsplit.Length; i++)
+                    {
+                        if (pointsplit[i].Length == 1)
+                        {
+                            switch (pointsplit[i])
+                            {
+                                case @"C":
+                                    curveType = CurveTypes.Catmull;
+                                    break;
+                                case @"B":
+                                    curveType = CurveTypes.Bezier;
+                                    break;
+                                case @"L":
+                                    curveType = CurveTypes.Linear;
+                                    break;
+                                case @"P":
+                                    curveType = CurveTypes.PerfectCurve;
+                                    break;
+                            }
+                            continue;
+                        }
+
+                        string[] temp = pointsplit[i].Split(':');
+                        Vector2 v = new Vector2(
+                            (int)Convert.ToDouble(temp[0], CultureInfo.InvariantCulture),
+                            (int)Convert.ToDouble(temp[1], CultureInfo.InvariantCulture)
+                        );
+                        points.Add(v);
+                    }
+
+                    repeatCount = Convert.ToInt32(split[6], CultureInfo.InvariantCulture);
+
+                    if (repeatCount > 9000)
+                    {
+                        throw new ArgumentOutOfRangeException("wacky man");
+                    }
+
+                    if (split.Length > 7)
+                        length = Convert.ToDouble(split[7], CultureInfo.InvariantCulture);
+
+                    s.RepeatCount = repeatCount;
+
+                    s.Curve = new SliderCurve
+                    {
+                        Path = points,
+                        Length = length,
+                        CurveType = curveType
+                    };
+
+                    s.Curve.Calculate();
+
+                    result = s;
                     break;
                 case OsuBaseHit.HitObjectType.Spinner:
                     result = new Spinner();

osu.Game.Mode.Osu/Objects/Slider.cs

@@ -8,8 +8,198 @@ namespace osu.Game.Modes.Osu.Objects
 {
     public class Slider : OsuBaseHit
     {
-        public List<Vector2> Path;
+        public override double EndTime => StartTime + (RepeatCount + 1) * Curve.Length;
 
         public int RepeatCount;
+
+        public SliderCurve Curve;
+        
     }
+
+    public class SliderCurve
+    {
+        public double Length;
+
+        public List<Vector2> Path;
+
+        public CurveTypes CurveType;
+
+        private List<Vector2> calculatedPath;
+
+        public void Calculate()
+        {
+            switch (CurveType)
+            {
+                case CurveTypes.Linear:
+                    calculatedPath = Path;
+                    break;
+                default:
+                    var bezier = new BezierApproximator(Path);
+                    calculatedPath = bezier.CreateBezier();
+                    break;
+            }
+        }
+
+        public Vector2 PositionAt(double progress)
+        {
+            int index = (int)(progress * (calculatedPath.Count - 1));
+
+            Vector2 pos = calculatedPath[index];
+            if (index != progress)
+                pos += (calculatedPath[index + 1] - pos) * (float)(progress - index);
+
+            return pos;
+        }
+    }
+
+    public class BezierApproximator
+    {
+        private int count;
+        private List<Vector2> controlPoints;
+        private Vector2[] subdivisionBuffer1;
+        private Vector2[] subdivisionBuffer2;
+
+        private const float TOLERANCE = 0.5f;
+        private const float TOLERANCE_SQ = TOLERANCE * TOLERANCE;
+
+        public BezierApproximator(List<Vector2> controlPoints)
+        {
+            this.controlPoints = controlPoints;
+            count = controlPoints.Count;
+
+            subdivisionBuffer1 = new Vector2[count];
+            subdivisionBuffer2 = new Vector2[count * 2 - 1];
+        }
+
+        /// <summary>
+        /// Make sure the 2nd order derivative (approximated using finite elements) is within tolerable bounds.
+        /// NOTE: The 2nd order derivative of a 2d curve represents its curvature, so intuitively this function
+        ///       checks (as the name suggests) whether our approximation is _locally_ "flat". More curvy parts
+        ///       need to have a denser approximation to be more "flat".
+        /// </summary>
+        /// <param name="controlPoints">The control points to check for flatness.</param>
+        /// <returns>Whether the control points are flat enough.</returns>
+        private static bool IsFlatEnough(Vector2[] controlPoints)
+        {
+            for (int i = 1; i < controlPoints.Length - 1; i++)
+                if ((controlPoints[i - 1] - 2 * controlPoints[i] + controlPoints[i + 1]).LengthSquared > TOLERANCE_SQ)
+                    return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Subdivides n control points representing a bezier curve into 2 sets of n control points, each
+        /// describing a bezier curve equivalent to a half of the original curve. Effectively this splits
+        /// the original curve into 2 curves which result in the original curve when pieced back together.
+        /// </summary>
+        /// <param name="controlPoints">The control points to split.</param>
+        /// <param name="l">Output: The control points corresponding to the left half of the curve.</param>
+        /// <param name="r">Output: The control points corresponding to the right half of the curve.</param>
+        private void Subdivide(Vector2[] controlPoints, Vector2[] l, Vector2[] r)
+        {
+            Vector2[] midpoints = subdivisionBuffer1;
+
+            for (int i = 0; i < count; ++i)
+                midpoints[i] = controlPoints[i];
+
+            for (int i = 0; i < count; i++)
+            {
+                l[i] = midpoints[0];
+                r[count - i - 1] = midpoints[count - i - 1];
+
+                for (int j = 0; j < count - i - 1; j++)
+                    midpoints[j] = (midpoints[j] + midpoints[j + 1]) / 2;
+            }
+        }
+
+        /// <summary>
+        /// This uses <a href="https://en.wikipedia.org/wiki/De_Casteljau%27s_algorithm">De Casteljau's algorithm</a> to obtain an optimal
+        /// piecewise-linear approximation of the bezier curve with the same amount of points as there are control points.
+        /// </summary>
+        /// <param name="controlPoints">The control points describing the bezier curve to be approximated.</param>
+        /// <param name="output">The points representing the resulting piecewise-linear approximation.</param>
+        private void Approximate(Vector2[] controlPoints, List<Vector2> output)
+        {
+            Vector2[] l = subdivisionBuffer2;
+            Vector2[] r = subdivisionBuffer1;
+
+            Subdivide(controlPoints, l, r);
+
+            for (int i = 0; i < count - 1; ++i)
+                l[count + i] = r[i + 1];
+
+            output.Add(controlPoints[0]);
+            for (int i = 1; i < count - 1; ++i)
+            {
+                int index = 2 * i;
+                Vector2 p = 0.25f * (l[index - 1] + 2 * l[index] + l[index + 1]);
+                output.Add(p);
+            }
+        }
+
+        /// <summary>
+        /// Creates a piecewise-linear approximation of a bezier curve, by adaptively repeatedly subdividing
+        /// the control points until their approximation error vanishes below a given threshold.
+        /// </summary>
+        /// <param name="controlPoints">The control points describing the curve.</param>
+        /// <returns>A list of vectors representing the piecewise-linear approximation.</returns>
+        public List<Vector2> CreateBezier()
+        {
+            List<Vector2> output = new List<Vector2>();
+
+            if (count == 0)
+                return output;
+
+            Stack<Vector2[]> toFlatten = new Stack<Vector2[]>();
+            Stack<Vector2[]> freeBuffers = new Stack<Vector2[]>();
+
+            // "toFlatten" contains all the curves which are not yet approximated well enough.
+            // We use a stack to emulate recursion without the risk of running into a stack overflow.
+            // (More specifically, we iteratively and adaptively refine our curve with a 
+            // <a href="https://en.wikipedia.org/wiki/Depth-first_search">Depth-first search</a>
+            // over the tree resulting from the subdivisions we make.)
+            toFlatten.Push(controlPoints.ToArray());
+
+            Vector2[] leftChild = subdivisionBuffer2;
+
+            while (toFlatten.Count > 0)
+            {
+                Vector2[] parent = toFlatten.Pop();
+                if (IsFlatEnough(parent))
+                {
+                    // If the control points we currently operate on are sufficiently "flat", we use
+                    // an extension to De Casteljau's algorithm to obtain a piecewise-linear approximation
+                    // of the bezier curve represented by our control points, consisting of the same amount
+                    // of points as there are control points.
+                    Approximate(parent, output);
+                    freeBuffers.Push(parent);
+                    continue;
+                }
+
+                // If we do not yet have a sufficiently "flat" (in other words, detailed) approximation we keep
+                // subdividing the curve we are currently operating on.
+                Vector2[] rightChild = freeBuffers.Count > 0 ? freeBuffers.Pop() : new Vector2[count];
+                Subdivide(parent, leftChild, rightChild);
+
+                // We re-use the buffer of the parent for one of the children, so that we save one allocation per iteration.
+                for (int i = 0; i < count; ++i)
+                    parent[i] = leftChild[i];
+
+                toFlatten.Push(rightChild);
+                toFlatten.Push(parent);
+            }
+
+            output.Add(controlPoints[count - 1]);
+            return output;
+        }
+    }
+
+    public enum CurveTypes
+    {
+        Catmull,
+        Bezier,
+        Linear,
+        PerfectCurve
+    };
 }

osu.Game.Mode.Osu/UI/OsuHitRenderer.cs

@@ -18,6 +18,13 @@ namespace osu.Game.Modes.Osu.UI
         protected override Playfield CreatePlayfield() => new OsuPlayfield();
 
         protected override DrawableHitObject GetVisualRepresentation(OsuBaseHit h)
-            => h is HitCircle ? new DrawableHitCircle(h as HitCircle) : null;
+        {
+            if (h is HitCircle)
+                return new DrawableHitCircle(h as HitCircle);
+            if (h is Slider)
+                return new DrawableSlider(h as Slider);
+
+            return null;
+        }
     }
 }