Merge branch 'master' into cinema-mod

CodeAnalysis/BannedSymbols.txt

@@ -2,4 +2,4 @@ M:System.Object.Equals(System.Object,System.Object)~System.Boolean;Don't use obj
 M:System.Object.Equals(System.Object)~System.Boolean;Don't use object.Equals. Use IEquatable<T> or EqualityComparer<T>.Default instead.
 M:System.ValueType.Equals(System.Object)~System.Boolean;Don't use object.Equals(Fallbacks to ValueType). Use IEquatable<T> or EqualityComparer<T>.Default instead.
 T:System.IComparable;Don't use non-generic IComparable. Use generic version instead.
-T:osu.Framework.Graphics.Sprites.SpriteText.#ctor;Use OsuSpriteText.
+M:osu.Framework.Graphics.Sprites.SpriteText.#ctor;Use OsuSpriteText.

osu.Android.props

@@ -16,8 +16,6 @@
     <AndroidSupportedAbis>armeabi-v7a;x86;arm64-v8a</AndroidSupportedAbis>
     <AndroidEnableSGenConcurrent>true</AndroidEnableSGenConcurrent>
     <MandroidI18n>cjk,mideast,other,rare,west</MandroidI18n>
-    <AndroidHttpClientHandlerType>System.Net.Http.HttpClientHandler</AndroidHttpClientHandlerType>
-    <AndroidTlsProvider>legacy</AndroidTlsProvider>
     <AndroidLinkMode>SdkOnly</AndroidLinkMode>
     <ErrorReport>prompt</ErrorReport>
   </PropertyGroup>

osu.Game.Rulesets.Catch/Objects/Drawable/DrawableCatchHitObject.cs

@@ -4,8 +4,8 @@
 using System;
 using osuTK;
 using osu.Framework.Graphics;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
-using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Catch.Objects.Drawable
@@ -68,7 +68,7 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
 
         protected override void UpdateStateTransforms(ArmedState state)
         {
-            var endTime = (HitObject as IHasEndTime)?.EndTime ?? HitObject.StartTime;
+            var endTime = HitObject.GetEndTime();
 
             using (BeginAbsoluteSequence(endTime, true))
             {

osu.Game.Rulesets.Mania.Tests/ManiaBeatmapConversionTest.cs

@@ -9,7 +9,6 @@ using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Tests.Beatmaps;
 
 namespace osu.Game.Rulesets.Mania.Tests
@@ -27,7 +26,7 @@ namespace osu.Game.Rulesets.Mania.Tests
             yield return new ConvertValue
             {
                 StartTime = hitObject.StartTime,
-                EndTime = (hitObject as IHasEndTime)?.EndTime ?? hitObject.StartTime,
+                EndTime = hitObject.GetEndTime(),
                 Column = ((ManiaHitObject)hitObject).Column
             };
         }

osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/DistanceObjectPatternGenerator.cs

@@ -77,7 +77,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
 
             foreach (var obj in originalPattern.HitObjects)
             {
-                if (!Precision.AlmostEquals(EndTime, (obj as IHasEndTime)?.EndTime ?? obj.StartTime))
+                if (!Precision.AlmostEquals(EndTime, obj.GetEndTime()))
                     intermediatePattern.Add(obj);
                 else
                     endTimePattern.Add(obj);

osu.Game.Rulesets.Mania/Replays/ManiaAutoGenerator.cs

@@ -6,7 +6,6 @@ using System.Linq;
 using osu.Game.Replays;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Replays;
 
 namespace osu.Game.Rulesets.Mania.Replays
@@ -84,7 +83,7 @@ namespace osu.Game.Rulesets.Mania.Replays
                 var currentObject = Beatmap.HitObjects[i];
                 var nextObjectInColumn = GetNextObject(i); // Get the next object that requires pressing the same button
 
-                double endTime = (currentObject as IHasEndTime)?.EndTime ?? currentObject.StartTime;
+                double endTime = currentObject.GetEndTime();
 
                 bool canDelayKeyUp = nextObjectInColumn == null ||
                                      nextObjectInColumn.StartTime > endTime + RELEASE_DELAY;

osu.Game.Rulesets.Osu.Tests/OsuBeatmapConversionTest.cs

@@ -6,7 +6,6 @@ using System.Collections.Generic;
 using NUnit.Framework;
 using osu.Framework.MathUtils;
 using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Tests.Beatmaps;
 
@@ -44,7 +43,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             ConvertValue createConvertValue(OsuHitObject obj) => new ConvertValue
             {
                 StartTime = obj.StartTime,
-                EndTime = (obj as IHasEndTime)?.EndTime ?? obj.StartTime,
+                EndTime = obj.GetEndTime(),
                 X = obj.StackedPosition.X,
                 Y = obj.StackedPosition.Y
             };

osu.Game.Rulesets.Osu/Beatmaps/OsuBeatmapProcessor.cs

@@ -4,7 +4,7 @@
 using System;
 using osu.Framework.Graphics;
 using osu.Game.Beatmaps;
-using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Objects;
 using osuTK;
 
@@ -62,7 +62,7 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                         if (objectN is Spinner)
                             continue;
 
-                        double endTime = (stackBaseObject as IHasEndTime)?.EndTime ?? stackBaseObject.StartTime;
+                        double endTime = stackBaseObject.GetEndTime();
                         double stackThreshold = objectN.TimePreempt * beatmap.BeatmapInfo.StackLeniency;
 
                         if (objectN.StartTime - endTime > stackThreshold)
@@ -121,7 +121,7 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                         OsuHitObject objectN = beatmap.HitObjects[n];
                         if (objectN is Spinner) continue;
 
-                        double endTime = (objectN as IHasEndTime)?.EndTime ?? objectN.StartTime;
+                        double endTime = objectN.GetEndTime();
 
                         if (objectI.StartTime - endTime > stackThreshold)
                             //We are no longer within stacking range of the previous object.
@@ -199,7 +199,7 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                 if (currHitObject.StackHeight != 0 && !(currHitObject is Slider))
                     continue;
 
-                double startTime = (currHitObject as IHasEndTime)?.EndTime ?? currHitObject.StartTime;
+                double startTime = currHitObject.GetEndTime();
                 int sliderStack = 0;
 
                 for (int j = i + 1; j < beatmap.HitObjects.Count; j++)
@@ -217,14 +217,14 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                     if (Vector2Extensions.Distance(beatmap.HitObjects[j].Position, currHitObject.Position) < stack_distance)
                     {
                         currHitObject.StackHeight++;
-                        startTime = (beatmap.HitObjects[j] as IHasEndTime)?.EndTime ?? beatmap.HitObjects[j].StartTime;
+                        startTime = beatmap.HitObjects[j].GetEndTime();
                     }
                     else if (Vector2Extensions.Distance(beatmap.HitObjects[j].Position, position2) < stack_distance)
                     {
                         //Case for sliders - bump notes down and right, rather than up and left.
                         sliderStack++;
                         beatmap.HitObjects[j].StackHeight -= sliderStack;
-                        startTime = (beatmap.HitObjects[j] as IHasEndTime)?.EndTime ?? beatmap.HitObjects[j].StartTime;
+                        startTime = beatmap.HitObjects[j].GetEndTime();
                     }
                 }
             }

osu.Game.Rulesets.Osu/Mods/OsuModHidden.cs

@@ -6,9 +6,9 @@ using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
-using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Objects;
 
 namespace osu.Game.Rulesets.Osu.Mods
@@ -48,7 +48,7 @@ namespace osu.Game.Rulesets.Osu.Mods
             var fadeOutDuration = h.TimePreempt * fade_out_duration_multiplier;
 
             // new duration from completed fade in to end (before fading out)
-            var longFadeDuration = ((h as IHasEndTime)?.EndTime ?? h.StartTime) - fadeOutStartTime;
+            var longFadeDuration = h.GetEndTime() - fadeOutStartTime;
 
             switch (drawable)
             {

osu.Game.Rulesets.Osu/Objects/Drawables/Connections/FollowPointConnection.cs

@@ -6,7 +6,7 @@ using JetBrains.Annotations;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Objects;
 using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
@@ -99,7 +99,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
 
             Vector2 startPosition = osuStart.EndPosition;
             Vector2 endPosition = osuEnd.Position;
-            double startTime = (osuStart as IHasEndTime)?.EndTime ?? osuStart.StartTime;
+            double startTime = osuStart.GetEndTime();
             double endTime = osuEnd.StartTime;
 
             Vector2 distanceVector = endPosition - startPosition;

osu.Game.Rulesets.Osu/Replays/OsuAutoGenerator.cs

@@ -10,7 +10,7 @@ using System.Diagnostics;
 using System.Linq;
 using osu.Framework.Graphics;
 using osu.Game.Replays;
-using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Beatmaps;
 using osu.Game.Rulesets.Osu.Scoring;
 using osu.Game.Rulesets.Scoring;
@@ -96,7 +96,7 @@ namespace osu.Game.Rulesets.Osu.Replays
 
         private void addDelayedMovements(OsuHitObject h, OsuHitObject prev)
         {
-            double endTime = (prev as IHasEndTime)?.EndTime ?? prev.StartTime;
+            double endTime = prev.GetEndTime();
 
             HitWindows hitWindows = null;
 
@@ -275,7 +275,7 @@ namespace osu.Game.Rulesets.Osu.Replays
             var startFrame = new OsuReplayFrame(h.StartTime, new Vector2(startPosition.X, startPosition.Y), action);
 
             // TODO: Why do we delay 1 ms if the object is a spinner? There already is KEY_UP_DELAY from hEndTime.
-            double hEndTime = ((h as IHasEndTime)?.EndTime ?? h.StartTime) + KEY_UP_DELAY;
+            double hEndTime = h.GetEndTime() + KEY_UP_DELAY;
             int endDelay = h is Spinner ? 1 : 0;
             var endFrame = new OsuReplayFrame(hEndTime + endDelay, new Vector2(h.StackedEndPosition.X, h.StackedEndPosition.Y));
 

osu.Game.Rulesets.Taiko.Tests/TaikoBeatmapConversionTest.cs

@@ -6,7 +6,6 @@ using System.Collections.Generic;
 using NUnit.Framework;
 using osu.Framework.MathUtils;
 using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Taiko.Objects;
 using osu.Game.Tests.Beatmaps;
 
@@ -27,7 +26,7 @@ namespace osu.Game.Rulesets.Taiko.Tests
             yield return new ConvertValue
             {
                 StartTime = hitObject.StartTime,
-                EndTime = (hitObject as IHasEndTime)?.EndTime ?? hitObject.StartTime,
+                EndTime = hitObject.GetEndTime(),
                 IsRim = hitObject is RimHit,
                 IsCentre = hitObject is CentreHit,
                 IsDrumRoll = hitObject is DrumRoll,

osu.Game.Tournament/Components/SongBar.cs

@@ -3,6 +3,7 @@
 
 using System;
 using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -13,6 +14,7 @@ using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Legacy;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
+using osu.Game.Rulesets;
 using osu.Game.Screens.Menu;
 using osuTK;
 using osuTK.Graphics;
@@ -23,6 +25,9 @@ namespace osu.Game.Tournament.Components
     {
         private BeatmapInfo beatmap;
 
+        [Resolved]
+        private IBindable<RulesetInfo> ruleset { get; set; }
+
         public BeatmapInfo Beatmap
         {
             get => beatmap;
@@ -165,7 +170,8 @@ namespace osu.Game.Tournament.Components
             string hardRockExtra = "";
             string srExtra = "";
 
-            //var ar = beatmap.BaseDifficulty.ApproachRate;
+            var ar = beatmap.BaseDifficulty.ApproachRate;
+
             if ((mods & LegacyMods.HardRock) > 0)
             {
                 hardRockExtra = "*";
@@ -174,12 +180,46 @@ namespace osu.Game.Tournament.Components
 
             if ((mods & LegacyMods.DoubleTime) > 0)
             {
-                //ar *= 1.5f;
+                // temporary local calculation (taken from OsuDifficultyCalculator)
+                double preempt = (int)BeatmapDifficulty.DifficultyRange(ar, 1800, 1200, 450) / 1.5;
+                ar = (float)(preempt > 1200 ? (1800 - preempt) / 120 : (1200 - preempt) / 150 + 5);
+
                 bpm *= 1.5f;
                 length /= 1.5f;
                 srExtra = "*";
             }
 
+            (string heading, string content)[] stats;
+
+            switch (ruleset.Value.ID)
+            {
+                default:
+                    stats = new (string heading, string content)[]
+                    {
+                        ("CS", $"{beatmap.BaseDifficulty.CircleSize:0.#}{hardRockExtra}"),
+                        ("AR", $"{ar:0.#}{hardRockExtra}"),
+                        ("OD", $"{beatmap.BaseDifficulty.OverallDifficulty:0.#}{hardRockExtra}"),
+                    };
+                    break;
+
+                case 1:
+                case 3:
+                    stats = new (string heading, string content)[]
+                    {
+                        ("OD", $"{beatmap.BaseDifficulty.OverallDifficulty:0.#}{hardRockExtra}"),
+                        ("HP", $"{beatmap.BaseDifficulty.DrainRate:0.#}{hardRockExtra}")
+                    };
+                    break;
+
+                case 2:
+                    stats = new (string heading, string content)[]
+                    {
+                        ("CS", $"{beatmap.BaseDifficulty.CircleSize:0.#}{hardRockExtra}"),
+                        ("AR", $"{ar:0.#}"),
+                    };
+                    break;
+            }
+
             panelContents.Children = new Drawable[]
             {
                 new DiffPiece(("Length", TimeSpan.FromMilliseconds(length).ToString(@"mm\:ss")))
@@ -192,12 +232,7 @@ namespace osu.Game.Tournament.Components
                     Anchor = Anchor.CentreLeft,
                     Origin = Anchor.TopLeft
                 },
-                new DiffPiece(
+                new DiffPiece(stats)
-                    //("CS", $"{beatmap.BaseDifficulty.CircleSize:0.#}{hardRockExtra}"),
-                    //("AR", $"{ar:0.#}{srExtra}"),
-                    ("OD", $"{beatmap.BaseDifficulty.OverallDifficulty:0.#}{hardRockExtra}"),
-                    ("HP", $"{beatmap.BaseDifficulty.DrainRate:0.#}{hardRockExtra}")
-                )
                 {
                     Anchor = Anchor.CentreRight,
                     Origin = Anchor.BottomRight

osu.Game/Beatmaps/BeatmapManager.cs

@@ -25,7 +25,7 @@ using osu.Game.IO.Archives;
 using osu.Game.Online.API;
 using osu.Game.Online.API.Requests;
 using osu.Game.Rulesets;
-using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Objects;
 
 namespace osu.Game.Beatmaps
 {
@@ -334,7 +334,8 @@ namespace osu.Game.Beatmaps
 
             var lastObject = b.HitObjects.Last();
 
-            double endTime = (lastObject as IHasEndTime)?.EndTime ?? lastObject.StartTime;
+            //TODO: this isn't always correct (consider mania where a non-last object may last for longer than the last in the list).
+            double endTime = lastObject.GetEndTime();
             double startTime = b.HitObjects.First().StartTime;
 
             return endTime - startTime;

osu.Game/Overlays/Settings/Sections/General/LoginSettings.cs

@@ -225,7 +225,7 @@ namespace osu.Game.Overlays.Settings.Sections.General
                 {
                     username = new OsuTextBox
                     {
-                        PlaceholderText = "email address",
+                        PlaceholderText = "username",
                         RelativeSizeAxes = Axes.X,
                         Text = api?.ProvidedUsername ?? string.Empty,
                         TabbableContentContainer = this
@@ -239,7 +239,7 @@ namespace osu.Game.Overlays.Settings.Sections.General
                     },
                     new SettingsCheckbox
                     {
-                        LabelText = "Remember email address",
+                        LabelText = "Remember username",
                         Bindable = config.GetBindable<bool>(OsuSetting.SaveUsername),
                     },
                     new SettingsCheckbox

osu.Game/Rulesets/Mods/ModTimeRamp.cs

@@ -8,7 +8,6 @@ using osu.Framework.Timing;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.Objects.Types;
 
 namespace osu.Game.Rulesets.Mods
 {
@@ -42,7 +41,7 @@ namespace osu.Game.Rulesets.Mods
             HitObject lastObject = beatmap.HitObjects.LastOrDefault();
 
             beginRampTime = beatmap.HitObjects.FirstOrDefault()?.StartTime ?? 0;
-            finalRateTime = final_rate_progress * ((lastObject as IHasEndTime)?.EndTime ?? lastObject?.StartTime ?? 0);
+            finalRateTime = final_rate_progress * (lastObject?.GetEndTime() ?? 0);
         }
 
         public virtual void Update(Playfield playfield)

osu.Game/Rulesets/Objects/BarLineGenerator.cs

@@ -6,7 +6,6 @@ using System.Linq;
 using osu.Framework.MathUtils;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
-using osu.Game.Rulesets.Objects.Types;
 
 namespace osu.Game.Rulesets.Objects
 {
@@ -28,7 +27,7 @@ namespace osu.Game.Rulesets.Objects
                 return;
 
             HitObject lastObject = beatmap.HitObjects.Last();
-            double lastHitTime = 1 + ((lastObject as IHasEndTime)?.EndTime ?? lastObject.StartTime);
+            double lastHitTime = 1 + lastObject.GetEndTime();
 
             var timingPoints = beatmap.ControlPointInfo.TimingPoints;
 

osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs

@@ -382,7 +382,7 @@ namespace osu.Game.Rulesets.Objects.Drawables
 
             if (Result != null && Result.HasResult)
             {
-                var endTime = (HitObject as IHasEndTime)?.EndTime ?? HitObject.StartTime;
+                var endTime = HitObject.GetEndTime();
 
                 if (Result.TimeOffset + endTime > Time.Current)
                 {
@@ -460,7 +460,7 @@ namespace osu.Game.Rulesets.Objects.Drawables
                 throw new InvalidOperationException($"{GetType().ReadableName()} applied a {nameof(JudgementResult)} but did not update {nameof(JudgementResult.Type)}.");
 
             // Ensure that the judgement is given a valid time offset, because this may not get set by the caller
-            var endTime = (HitObject as IHasEndTime)?.EndTime ?? HitObject.StartTime;
+            var endTime = HitObject.GetEndTime();
 
             Result.TimeOffset = Math.Min(HitObject.HitWindows.WindowFor(HitResult.Miss), Time.Current - endTime);
 
@@ -495,7 +495,7 @@ namespace osu.Game.Rulesets.Objects.Drawables
             if (Judged)
                 return false;
 
-            var endTime = (HitObject as IHasEndTime)?.EndTime ?? HitObject.StartTime;
+            var endTime = HitObject.GetEndTime();
             CheckForResult(userTriggered, Time.Current - endTime);
 
             return Judged;

osu.Game/Rulesets/Objects/HitObject.cs

@@ -158,4 +158,17 @@ namespace osu.Game.Rulesets.Objects
         [NotNull]
         protected virtual HitWindows CreateHitWindows() => new HitWindows();
     }
+
+    public static class HitObjectExtensions
+    {
+        /// <summary>
+        /// Returns the end time of this object.
+        /// </summary>
+        /// <remarks>
+        /// This returns the <see cref="IHasEndTime.EndTime"/> where available, falling back to <see cref="HitObject.StartTime"/> otherwise.
+        /// </remarks>
+        /// <param name="hitObject">The object.</param>
+        /// <returns>The end time of this object.</returns>
+        public static double GetEndTime(this HitObject hitObject) => (hitObject as IHasEndTime)?.EndTime ?? hitObject.StartTime;
+    }
 }

osu.Game/Rulesets/UI/Scrolling/DrawableScrollingRuleset.cs

@@ -15,7 +15,6 @@ using osu.Game.Configuration;
 using osu.Game.Input.Bindings;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Timing;
 using osu.Game.Rulesets.UI.Scrolling.Algorithms;
 
@@ -112,7 +111,7 @@ namespace osu.Game.Rulesets.UI.Scrolling
         [BackgroundDependencyLoader]
         private void load()
         {
-            double lastObjectTime = (Objects.LastOrDefault() as IHasEndTime)?.EndTime ?? Objects.LastOrDefault()?.StartTime ?? double.MaxValue;
+            double lastObjectTime = Objects.LastOrDefault()?.GetEndTime() ?? double.MaxValue;
             double baseBeatLength = TimingControlPoint.DEFAULT_BEAT_LENGTH;
 
             if (RelativeScaleBeatLengths)

osu.Game/Screens/Edit/Compose/Components/DistanceSnapGrid.cs

@@ -10,7 +10,6 @@ using osu.Framework.Graphics.Containers;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.Objects.Types;
 using osuTK;
 
 namespace osu.Game.Screens.Edit.Compose.Components
@@ -70,7 +69,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
         [BackgroundDependencyLoader]
         private void load()
         {
-            StartTime = (hitObject as IHasEndTime)?.EndTime ?? hitObject.StartTime;
+            StartTime = hitObject.GetEndTime();
         }
 
         protected override void LoadComplete()

osu.Game/Screens/Play/SongProgress.cs

@@ -12,7 +12,6 @@ using System.Linq;
 using osu.Framework.Bindables;
 using osu.Framework.Timing;
 using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.UI;
 
 namespace osu.Game.Screens.Play
@@ -34,7 +33,8 @@ namespace osu.Game.Screens.Play
         public override bool HandleNonPositionalInput => AllowSeeking;
         public override bool HandlePositionalInput => AllowSeeking;
 
-        private double lastHitTime => ((objects.Last() as IHasEndTime)?.EndTime ?? objects.Last().StartTime) + 1;
+        //TODO: this isn't always correct (consider mania where a non-last object may last for longer than the last in the list).
+        private double lastHitTime => objects.Last().GetEndTime() + 1;
 
         private double firstHitTime => objects.First().StartTime;
 

osu.Game/Screens/Play/SongProgressGraph.cs

@@ -4,7 +4,6 @@
 using System.Linq;
 using System.Collections.Generic;
 using System.Diagnostics;
-using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Objects;
 
 namespace osu.Game.Screens.Play
@@ -26,7 +25,7 @@ namespace osu.Game.Screens.Play
                     return;
 
                 var firstHit = objects.First().StartTime;
-                var lastHit = objects.Max(o => (o as IHasEndTime)?.EndTime ?? o.StartTime);
+                var lastHit = objects.Max(o => o.GetEndTime());
 
                 if (lastHit == 0)
                     lastHit = objects.Last().StartTime;
@@ -35,7 +34,7 @@ namespace osu.Game.Screens.Play
 
                 foreach (var h in objects)
                 {
-                    var endTime = (h as IHasEndTime)?.EndTime ?? h.StartTime;
+                    var endTime = h.GetEndTime();
 
                     Debug.Assert(endTime >= h.StartTime);