Merge branch 'master' into beatmap-overlay-download

osu.Game/Beatmaps/BeatmapManager.cs

@@ -171,7 +171,7 @@ namespace osu.Game.Beatmaps
                 catch (Exception e)
                 {
                     e = e.InnerException ?? e;
-                    Logger.Error(e, @"Could not import beatmap set");
+                    Logger.Error(e, $@"Could not import beatmap set ({Path.GetFileName(path)})");
                 }
             }
 
@@ -496,7 +496,8 @@ namespace osu.Game.Beatmaps
             using (var stream = new StreamReader(reader.GetStream(mapName)))
                 metadata = BeatmapDecoder.GetDecoder(stream).Decode(stream).Metadata;
 
-            beatmapSet = new BeatmapSetInfo
+            // check if a set already exists with the same online id.
+            beatmapSet = beatmaps.BeatmapSets.FirstOrDefault(b => b.OnlineBeatmapSetID == metadata.OnlineBeatmapSetID) ?? new BeatmapSetInfo
             {
                 OnlineBeatmapSetID = metadata.OnlineBeatmapSetID,
                 Beatmaps = new List<BeatmapInfo>(),
@@ -523,16 +524,21 @@ namespace osu.Game.Beatmaps
                     beatmap.BeatmapInfo.Hash = ms.ComputeSHA2Hash();
                     beatmap.BeatmapInfo.MD5Hash = ms.ComputeMD5Hash();
 
-                    // TODO: Diff beatmap metadata with set metadata and leave it here if necessary
-                    beatmap.BeatmapInfo.Metadata = null;
+                    var existing = beatmaps.Beatmaps.FirstOrDefault(b => b.Hash == beatmap.BeatmapInfo.Hash || b.OnlineBeatmapID == beatmap.BeatmapInfo.OnlineBeatmapID);
 
-                    RulesetInfo ruleset = rulesets.GetRuleset(beatmap.BeatmapInfo.RulesetID);
+                    if (existing == null)
+                    {
+                        // TODO: Diff beatmap metadata with set metadata and leave it here if necessary
+                        beatmap.BeatmapInfo.Metadata = null;
 
-                    // TODO: this should be done in a better place once we actually need to dynamically update it.
-                    beatmap.BeatmapInfo.Ruleset = ruleset;
-                    beatmap.BeatmapInfo.StarDifficulty = ruleset?.CreateInstance()?.CreateDifficultyCalculator(beatmap).Calculate() ?? 0;
+                        RulesetInfo ruleset = rulesets.GetRuleset(beatmap.BeatmapInfo.RulesetID);
 
-                    beatmapSet.Beatmaps.Add(beatmap.BeatmapInfo);
+                        // TODO: this should be done in a better place once we actually need to dynamically update it.
+                        beatmap.BeatmapInfo.Ruleset = ruleset;
+                        beatmap.BeatmapInfo.StarDifficulty = ruleset?.CreateInstance()?.CreateDifficultyCalculator(beatmap).Calculate() ?? 0;
+
+                        beatmapSet.Beatmaps.Add(beatmap.BeatmapInfo);
+                    }
                 }
             }
 

osu.Game/Beatmaps/DifficultyCalculator.cs

@@ -3,6 +3,10 @@
 
 using osu.Game.Rulesets.Objects;
 using System.Collections.Generic;
+using osu.Game.Rulesets.Mods;
+using osu.Framework.Timing;
+using System.Linq;
+using osu.Framework.Extensions.IEnumerableExtensions;
 
 namespace osu.Game.Beatmaps
 {
@@ -10,45 +14,46 @@ namespace osu.Game.Beatmaps
     {
         protected double TimeRate = 1;
 
-        protected abstract double CalculateInternal(Dictionary<string, string> categoryDifficulty);
-
-        private void loadTiming()
-        {
-            // TODO: Handle mods
-            const int audio_rate = 100;
-            TimeRate = audio_rate / 100.0;
-        }
-
-        public double Calculate(Dictionary<string, string> categoryDifficulty = null)
-        {
-            loadTiming();
-            double difficulty = CalculateInternal(categoryDifficulty);
-            return difficulty;
-        }
+        public abstract double Calculate(Dictionary<string, string> categoryDifficulty = null);
     }
 
     public abstract class DifficultyCalculator<T> : DifficultyCalculator where T : HitObject
     {
-        protected readonly Beatmap Beatmap;
+        protected readonly Beatmap<T> Beatmap;
+        protected readonly Mod[] Mods;
 
-        protected List<T> Objects;
-
-        protected DifficultyCalculator(Beatmap beatmap)
+        protected DifficultyCalculator(Beatmap beatmap, Mod[] mods = null)
         {
-            Beatmap = beatmap;
+            Beatmap = CreateBeatmapConverter(beatmap).Convert(beatmap);
+            Mods = mods ?? new Mod[0];
 
-            Objects = CreateBeatmapConverter().Convert(beatmap).HitObjects;
 
-            foreach (var h in Objects)
-                h.ApplyDefaults(beatmap.ControlPointInfo, beatmap.BeatmapInfo.BaseDifficulty);
+            ApplyMods(Mods);
 
             PreprocessHitObjects();
         }
 
+        protected virtual void ApplyMods(Mod[] mods)
+        {
+            var clock = new StopwatchClock();
+            mods.OfType<IApplicableToClock>().ForEach(m => m.ApplyToClock(clock));
+            TimeRate = clock.Rate;
+
+            foreach (var mod in Mods.OfType<IApplicableToDifficulty>())
+                mod.ApplyToDifficulty(Beatmap.BeatmapInfo.BaseDifficulty);
+
+            foreach (var mod in mods.OfType<IApplicableToHitObject<T>>())
+                foreach (var obj in Beatmap.HitObjects)
+                    mod.ApplyToHitObject(obj);
+
+            foreach (var h in Beatmap.HitObjects)
+                h.ApplyDefaults(Beatmap.ControlPointInfo, Beatmap.BeatmapInfo.BaseDifficulty);
+        }
+
         protected virtual void PreprocessHitObjects()
         {
         }
 
-        protected abstract BeatmapConverter<T> CreateBeatmapConverter();
+        protected abstract BeatmapConverter<T> CreateBeatmapConverter(Beatmap beatmap);
     }
 }

osu.Game/Beatmaps/Drawables/BeatmapBackgroundSprite.cs

@@ -7,7 +7,7 @@ using osu.Framework.Graphics.Sprites;
 
 namespace osu.Game.Beatmaps.Drawables
 {
-    internal class BeatmapBackgroundSprite : Sprite
+    public class BeatmapBackgroundSprite : Sprite
     {
         private readonly WorkingBeatmap working;
 

osu.Game/Beatmaps/Drawables/BeatmapSetHeader.cs

@@ -11,7 +11,6 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Cursor;
-using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
 using osu.Game.Graphics.Sprites;
 using osu.Framework.Graphics.Shapes;
@@ -28,10 +27,8 @@ namespace osu.Game.Beatmaps.Drawables
 
         public Action<BeatmapSetInfo> RestoreHiddenRequested;
 
-        private readonly SpriteText title;
-        private readonly SpriteText artist;
-
         private readonly WorkingBeatmap beatmap;
+
         private readonly FillFlowContainer difficultyIcons;
 
         public BeatmapSetHeader(WorkingBeatmap beatmap)
@@ -41,6 +38,25 @@ namespace osu.Game.Beatmaps.Drawables
 
             this.beatmap = beatmap;
 
+            difficultyIcons = new FillFlowContainer
+            {
+                Margin = new MarginPadding { Top = 5 },
+                AutoSizeAxes = Axes.Both,
+            };
+        }
+
+        protected override void Selected()
+        {
+            base.Selected();
+            GainedSelection?.Invoke(this);
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(LocalisationEngine localisation)
+        {
+            if (localisation == null)
+                throw new ArgumentNullException(nameof(localisation));
+
             Children = new Drawable[]
             {
                 new DelayedLoadWrapper(
@@ -60,44 +76,26 @@ namespace osu.Game.Beatmaps.Drawables
                     AutoSizeAxes = Axes.Both,
                     Children = new Drawable[]
                     {
-                        title = new OsuSpriteText
+                        new OsuSpriteText
                         {
                             Font = @"Exo2.0-BoldItalic",
+                            Current = localisation.GetUnicodePreference(beatmap.Metadata.TitleUnicode, beatmap.Metadata.Title),
                             TextSize = 22,
                             Shadow = true,
                         },
-                        artist = new OsuSpriteText
+                        new OsuSpriteText
                         {
                             Font = @"Exo2.0-SemiBoldItalic",
+                            Current = localisation.GetUnicodePreference(beatmap.Metadata.ArtistUnicode, beatmap.Metadata.Artist),
                             TextSize = 17,
                             Shadow = true,
                         },
-                        difficultyIcons = new FillFlowContainer
-                        {
-                            Margin = new MarginPadding { Top = 5 },
-                            AutoSizeAxes = Axes.Both,
-                        }
+                        difficultyIcons
                     }
                 }
             };
         }
 
-        protected override void Selected()
-        {
-            base.Selected();
-            GainedSelection?.Invoke(this);
-        }
-
-        [BackgroundDependencyLoader]
-        private void load(LocalisationEngine localisation)
-        {
-            if (localisation == null)
-                throw new ArgumentNullException(nameof(localisation));
-
-            title.Current = localisation.GetUnicodePreference(beatmap.Metadata.TitleUnicode, beatmap.Metadata.Title);
-            artist.Current = localisation.GetUnicodePreference(beatmap.Metadata.ArtistUnicode, beatmap.Metadata.Artist);
-        }
-
         private class PanelBackground : BufferedContainer
         {
             public PanelBackground(WorkingBeatmap working)
@@ -185,4 +183,4 @@ namespace osu.Game.Beatmaps.Drawables
             }
         }
     }
-}
+}

osu.Game/Beatmaps/DummyWorkingBeatmap.cs

@@ -11,7 +11,7 @@ using osu.Game.Rulesets.UI;
 
 namespace osu.Game.Beatmaps
 {
-    internal class DummyWorkingBeatmap : WorkingBeatmap
+    public class DummyWorkingBeatmap : WorkingBeatmap
     {
         private readonly OsuGameBase game;
 
@@ -59,7 +59,7 @@ namespace osu.Game.Beatmaps
                     throw new NotImplementedException();
                 }
 
-                public override DifficultyCalculator CreateDifficultyCalculator(Beatmap beatmap) => null;
+                public override DifficultyCalculator CreateDifficultyCalculator(Beatmap beatmap, Mod[] mods = null) => null;
 
                 public override string Description => "dummy";
 

osu.Game/Beatmaps/WorkingBeatmap.cs

@@ -8,6 +8,7 @@ using osu.Game.Rulesets.Mods;
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
 
 namespace osu.Game.Beatmaps
 {
@@ -28,16 +29,11 @@ namespace osu.Game.Beatmaps
             Metadata = beatmapInfo.Metadata ?? BeatmapSetInfo?.Metadata ?? new BeatmapMetadata();
 
             Mods.ValueChanged += mods => applyRateAdjustments();
-        }
 
-        private void applyRateAdjustments()
-        {
-            var t = track;
-            if (t == null) return;
-
-            t.ResetSpeedAdjustments();
-            foreach (var mod in Mods.Value.OfType<IApplicableToClock>())
-                mod.ApplyToClock(t);
+            beatmap = new AsyncLazy<Beatmap>(populateBeatmap);
+            background = new AsyncLazy<Texture>(populateBackground);
+            track = new AsyncLazy<Track>(populateTrack);
+            waveform = new AsyncLazy<Waveform>(populateWaveform);
         }
 
         protected abstract Beatmap GetBeatmap();
@@ -45,97 +41,84 @@ namespace osu.Game.Beatmaps
         protected abstract Track GetTrack();
         protected virtual Waveform GetWaveform() => new Waveform();
 
-        private Beatmap beatmap;
-        private readonly object beatmapLock = new object();
-        public Beatmap Beatmap
+        public bool BeatmapLoaded => beatmap.IsValueCreated;
+        public Beatmap Beatmap => beatmap.Value.Result;
+        public async Task<Beatmap> GetBeatmapAsync() => await beatmap.Value;
+
+        private readonly AsyncLazy<Beatmap> beatmap;
+
+        private Beatmap populateBeatmap()
         {
-            get
-            {
-                lock (beatmapLock)
-                {
-                    if (beatmap != null) return beatmap;
+            var b = GetBeatmap() ?? new Beatmap();
 
-                    beatmap = GetBeatmap() ?? new Beatmap();
+            // use the database-backed info.
+            b.BeatmapInfo = BeatmapInfo;
 
-                    // use the database-backed info.
-                    beatmap.BeatmapInfo = BeatmapInfo;
-
-                    return beatmap;
-                }
-            }
+            return b;
         }
 
-        private readonly object backgroundLock = new object();
-        private Texture background;
-        public Texture Background
+        public bool BackgroundLoaded => background.IsValueCreated;
+        public Texture Background => background.Value.Result;
+        public async Task<Texture> GetBackgroundAsync() => await background.Value;
+        private AsyncLazy<Texture> background;
+
+        private Texture populateBackground() => GetBackground();
+
+        public bool TrackLoaded => track.IsValueCreated;
+        public Track Track => track.Value.Result;
+        public async Task<Track> GetTrackAsync() => await track.Value;
+        private AsyncLazy<Track> track;
+
+        private Track populateTrack()
         {
-            get
-            {
-                lock (backgroundLock)
-                {
-                    return background ?? (background = GetBackground());
-                }
-            }
+            // we want to ensure that we always have a track, even if it's a fake one.
+            var t = GetTrack() ?? new TrackVirtual();
+            applyRateAdjustments(t);
+            return t;
         }
 
-        private Track track;
-        private readonly object trackLock = new object();
-        public Track Track
-        {
-            get
-            {
-                lock (trackLock)
-                {
-                    if (track != null) return track;
+        public bool WaveformLoaded => waveform.IsValueCreated;
+        public Waveform Waveform => waveform.Value.Result;
+        public async Task<Waveform> GetWaveformAsync() => await waveform.Value;
+        private readonly AsyncLazy<Waveform> waveform;
 
-                    // we want to ensure that we always have a track, even if it's a fake one.
-                    track = GetTrack() ?? new TrackVirtual();
-
-                    applyRateAdjustments();
-                    return track;
-                }
-            }
-        }
-
-        private Waveform waveform;
-        private readonly object waveformLock = new object();
-        public Waveform Waveform
-        {
-            get
-            {
-                lock (waveformLock)
-                    return waveform ?? (waveform = GetWaveform());
-            }
-        }
-
-        public bool TrackLoaded => track != null;
+        private Waveform populateWaveform() => GetWaveform();
 
         public void TransferTo(WorkingBeatmap other)
         {
-            lock (trackLock)
-            {
-                if (track != null && BeatmapInfo.AudioEquals(other.BeatmapInfo))
-                    other.track = track;
-            }
+            if (track.IsValueCreated && Track != null && BeatmapInfo.AudioEquals(other.BeatmapInfo))
+                other.track = track;
 
-            if (background != null && BeatmapInfo.BackgroundEquals(other.BeatmapInfo))
+            if (background.IsValueCreated && Background != null && BeatmapInfo.BackgroundEquals(other.BeatmapInfo))
                 other.background = background;
         }
 
         public virtual void Dispose()
         {
-            background?.Dispose();
-            background = null;
-
-            waveform?.Dispose();
+            if (BackgroundLoaded) Background?.Dispose();
+            if (WaveformLoaded) Waveform?.Dispose();
         }
 
         public void DisposeTrack()
         {
-            lock (trackLock)
+            if (TrackLoaded) Track?.Dispose();
+        }
+
+        private void applyRateAdjustments(Track t = null)
+        {
+            if (t == null && track.IsValueCreated) t = Track;
+            if (t == null) return;
+
+            t.ResetSpeedAdjustments();
+            foreach (var mod in Mods.Value.OfType<IApplicableToClock>())
+                mod.ApplyToClock(t);
+        }
+
+        public class AsyncLazy<T> : Lazy<Task<T>>
+        {
+            public AsyncLazy(Func<T> valueFactory)
+                : base(() => Task.Run(valueFactory))
             {
-                track?.Dispose();
-                track = null;
             }
         }
     }

osu.Game/Database/OsuDbContext.cs

@@ -78,6 +78,7 @@ namespace osu.Game.Database
         {
             base.OnModelCreating(modelBuilder);
 
+            modelBuilder.Entity<BeatmapInfo>().HasIndex(b => b.OnlineBeatmapID).IsUnique();
             modelBuilder.Entity<BeatmapInfo>().HasIndex(b => b.MD5Hash).IsUnique();
             modelBuilder.Entity<BeatmapInfo>().HasIndex(b => b.Hash).IsUnique();
 

osu.Game/Graphics/Containers/BeatSyncedContainer.cs

@@ -35,15 +35,18 @@ namespace osu.Game.Graphics.Containers
 
         protected override void Update()
         {
-            var track = Beatmap.Value.Track;
+            if (!Beatmap.Value.TrackLoaded || !Beatmap.Value.BeatmapLoaded) return;
 
-            if (track == null)
+            var track = Beatmap.Value.Track;
+            var beatmap = Beatmap.Value.Beatmap;
+
+            if (track == null || beatmap == null)
                 return;
 
             double currentTrackTime = track.Length > 0 ? track.CurrentTime + EarlyActivationMilliseconds : Clock.CurrentTime;
 
-            TimingControlPoint timingPoint = Beatmap.Value.Beatmap.ControlPointInfo.TimingPointAt(currentTrackTime);
-            EffectControlPoint effectPoint = Beatmap.Value.Beatmap.ControlPointInfo.EffectPointAt(currentTrackTime);
+            TimingControlPoint timingPoint = beatmap.ControlPointInfo.TimingPointAt(currentTrackTime);
+            EffectControlPoint effectPoint = beatmap.ControlPointInfo.EffectPointAt(currentTrackTime);
 
             if (timingPoint.BeatLength == 0)
                 return;
@@ -64,7 +67,7 @@ namespace osu.Game.Graphics.Containers
                 return;
 
             using (BeginDelayedSequence(-TimeSinceLastBeat, true))
-                OnNewBeat(beatIndex, timingPoint, effectPoint, Beatmap.Value.Track.CurrentAmplitudes);
+                OnNewBeat(beatIndex, timingPoint, effectPoint, track.CurrentAmplitudes);
 
             lastBeat = beatIndex;
             lastTimingPoint = timingPoint;

osu.Game/Graphics/Containers/OsuScrollContainer.cs

@@ -7,7 +7,7 @@ using OpenTK.Input;
 
 namespace osu.Game.Graphics.Containers
 {
-    internal class OsuScrollContainer : ScrollContainer
+    public class OsuScrollContainer : ScrollContainer
     {
         /// <summary>
         /// Allows controlling the scroll bar from any position in the container using the right mouse button.

osu.Game/Graphics/UserInterface/DialogButton.cs

@@ -66,7 +66,7 @@ namespace osu.Game.Graphics.UserInterface
         }
 
         private float textSize = 28;
-        internal float TextSize
+        public float TextSize
         {
             get
             {

osu.Game/Graphics/UserInterface/FocusedTextBox.cs

@@ -38,7 +38,7 @@ namespace osu.Game.Graphics.UserInterface
 
         protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
         {
-            if (args.Key == Key.Escape)
+            if (!args.Repeat && args.Key == Key.Escape)
             {
                 if (Text.Length > 0)
                     Text = string.Empty;

osu.Game/Graphics/UserInterface/Volume/VolumeControl.cs

@@ -11,7 +11,7 @@ using osu.Game.Input.Bindings;
 
 namespace osu.Game.Graphics.UserInterface.Volume
 {
-    internal class VolumeControl : OverlayContainer
+    public class VolumeControl : OverlayContainer
     {
         private readonly VolumeMeter volumeMeterMaster;
 
@@ -119,4 +119,4 @@ namespace osu.Game.Graphics.UserInterface.Volume
             this.Delay(1000).Schedule(Hide, out popOutDelegate);
         }
     }
-}
+}

osu.Game/Graphics/UserInterface/Volume/VolumeControlReceptor.cs

@@ -8,7 +8,7 @@ using osu.Game.Input.Bindings;
 
 namespace osu.Game.Graphics.UserInterface.Volume
 {
-    internal class VolumeControlReceptor : Container, IKeyBindingHandler<GlobalAction>
+    public class VolumeControlReceptor : Container, IKeyBindingHandler<GlobalAction>
     {
         public Func<GlobalAction, bool> ActionRequested;
 

osu.Game/Graphics/UserInterface/Volume/VolumeMeter.cs

@@ -13,7 +13,7 @@ using osu.Game.Input.Bindings;
 
 namespace osu.Game.Graphics.UserInterface.Volume
 {
-    internal class VolumeMeter : Container, IKeyBindingHandler<GlobalAction>
+    public class VolumeMeter : Container, IKeyBindingHandler<GlobalAction>
     {
         private readonly Box meterFill;
         public BindableDouble Bindable { get; } = new BindableDouble();
@@ -108,4 +108,4 @@ namespace osu.Game.Graphics.UserInterface.Volume
 
         public bool OnReleased(GlobalAction action) => false;
     }
-}
+}

osu.Game/Migrations/20171119065731_AddBeatmapOnlineIDUniqueConstraint.Designer.cs

@@ -0,0 +1,302 @@
+// <auto-generated />
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage;
+using osu.Game.Database;
+using System;
+
+namespace osu.Game.Migrations
+{
+    [DbContext(typeof(OsuDbContext))]
+    [Migration("20171119065731_AddBeatmapOnlineIDUniqueConstraint")]
+    partial class AddBeatmapOnlineIDUniqueConstraint
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "2.0.0-rtm-26452");
+
+            modelBuilder.Entity("osu.Game.Beatmaps.BeatmapDifficulty", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<float>("ApproachRate");
+
+                    b.Property<float>("CircleSize");
+
+                    b.Property<float>("DrainRate");
+
+                    b.Property<float>("OverallDifficulty");
+
+                    b.Property<float>("SliderMultiplier");
+
+                    b.Property<float>("SliderTickRate");
+
+                    b.HasKey("ID");
+
+                    b.ToTable("BeatmapDifficulty");
+                });
+
+            modelBuilder.Entity("osu.Game.Beatmaps.BeatmapInfo", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("AudioLeadIn");
+
+                    b.Property<int>("BaseDifficultyID");
+
+                    b.Property<int>("BeatDivisor");
+
+                    b.Property<int>("BeatmapSetInfoID");
+
+                    b.Property<bool>("Countdown");
+
+                    b.Property<double>("DistanceSpacing");
+
+                    b.Property<int>("GridSize");
+
+                    b.Property<string>("Hash");
+
+                    b.Property<bool>("Hidden");
+
+                    b.Property<bool>("LetterboxInBreaks");
+
+                    b.Property<string>("MD5Hash");
+
+                    b.Property<int?>("MetadataID");
+
+                    b.Property<int?>("OnlineBeatmapID");
+
+                    b.Property<string>("Path");
+
+                    b.Property<int>("RulesetID");
+
+                    b.Property<bool>("SpecialStyle");
+
+                    b.Property<float>("StackLeniency");
+
+                    b.Property<double>("StarDifficulty");
+
+                    b.Property<string>("StoredBookmarks");
+
+                    b.Property<double>("TimelineZoom");
+
+                    b.Property<string>("Version");
+
+                    b.Property<bool>("WidescreenStoryboard");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("BaseDifficultyID");
+
+                    b.HasIndex("BeatmapSetInfoID");
+
+                    b.HasIndex("Hash")
+                        .IsUnique();
+
+                    b.HasIndex("MD5Hash")
+                        .IsUnique();
+
+                    b.HasIndex("MetadataID");
+
+                    b.HasIndex("OnlineBeatmapID")
+                        .IsUnique();
+
+                    b.HasIndex("RulesetID");
+
+                    b.ToTable("BeatmapInfo");
+                });
+
+            modelBuilder.Entity("osu.Game.Beatmaps.BeatmapMetadata", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Artist");
+
+                    b.Property<string>("ArtistUnicode");
+
+                    b.Property<string>("AudioFile");
+
+                    b.Property<string>("AuthorString")
+                        .HasColumnName("Author");
+
+                    b.Property<string>("BackgroundFile");
+
+                    b.Property<int>("PreviewTime");
+
+                    b.Property<string>("Source");
+
+                    b.Property<string>("Tags");
+
+                    b.Property<string>("Title");
+
+                    b.Property<string>("TitleUnicode");
+
+                    b.HasKey("ID");
+
+                    b.ToTable("BeatmapMetadata");
+                });
+
+            modelBuilder.Entity("osu.Game.Beatmaps.BeatmapSetFileInfo", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("BeatmapSetInfoID");
+
+                    b.Property<int>("FileInfoID");
+
+                    b.Property<string>("Filename")
+                        .IsRequired();
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("BeatmapSetInfoID");
+
+                    b.HasIndex("FileInfoID");
+
+                    b.ToTable("BeatmapSetFileInfo");
+                });
+
+            modelBuilder.Entity("osu.Game.Beatmaps.BeatmapSetInfo", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<bool>("DeletePending");
+
+                    b.Property<string>("Hash");
+
+                    b.Property<int?>("MetadataID");
+
+                    b.Property<int?>("OnlineBeatmapSetID");
+
+                    b.Property<bool>("Protected");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("DeletePending");
+
+                    b.HasIndex("Hash")
+                        .IsUnique();
+
+                    b.HasIndex("MetadataID");
+
+                    b.HasIndex("OnlineBeatmapSetID")
+                        .IsUnique();
+
+                    b.ToTable("BeatmapSetInfo");
+                });
+
+            modelBuilder.Entity("osu.Game.Input.Bindings.DatabasedKeyBinding", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("IntAction")
+                        .HasColumnName("Action");
+
+                    b.Property<string>("KeysString")
+                        .HasColumnName("Keys");
+
+                    b.Property<int?>("RulesetID");
+
+                    b.Property<int?>("Variant");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("IntAction");
+
+                    b.HasIndex("Variant");
+
+                    b.ToTable("KeyBinding");
+                });
+
+            modelBuilder.Entity("osu.Game.IO.FileInfo", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Hash");
+
+                    b.Property<int>("ReferenceCount");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("Hash")
+                        .IsUnique();
+
+                    b.HasIndex("ReferenceCount");
+
+                    b.ToTable("FileInfo");
+                });
+
+            modelBuilder.Entity("osu.Game.Rulesets.RulesetInfo", b =>
+                {
+                    b.Property<int?>("ID")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<bool>("Available");
+
+                    b.Property<string>("InstantiationInfo");
+
+                    b.Property<string>("Name");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("Available");
+
+                    b.ToTable("RulesetInfo");
+                });
+
+            modelBuilder.Entity("osu.Game.Beatmaps.BeatmapInfo", b =>
+                {
+                    b.HasOne("osu.Game.Beatmaps.BeatmapDifficulty", "BaseDifficulty")
+                        .WithMany()
+                        .HasForeignKey("BaseDifficultyID")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("osu.Game.Beatmaps.BeatmapSetInfo", "BeatmapSet")
+                        .WithMany("Beatmaps")
+                        .HasForeignKey("BeatmapSetInfoID")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("osu.Game.Beatmaps.BeatmapMetadata", "Metadata")
+                        .WithMany("Beatmaps")
+                        .HasForeignKey("MetadataID");
+
+                    b.HasOne("osu.Game.Rulesets.RulesetInfo", "Ruleset")
+                        .WithMany()
+                        .HasForeignKey("RulesetID")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("osu.Game.Beatmaps.BeatmapSetFileInfo", b =>
+                {
+                    b.HasOne("osu.Game.Beatmaps.BeatmapSetInfo")
+                        .WithMany("Files")
+                        .HasForeignKey("BeatmapSetInfoID")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("osu.Game.IO.FileInfo", "FileInfo")
+                        .WithMany()
+                        .HasForeignKey("FileInfoID")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("osu.Game.Beatmaps.BeatmapSetInfo", b =>
+                {
+                    b.HasOne("osu.Game.Beatmaps.BeatmapMetadata", "Metadata")
+                        .WithMany("BeatmapSets")
+                        .HasForeignKey("MetadataID");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

osu.Game/Migrations/20171119065731_AddBeatmapOnlineIDUniqueConstraint.cs

@@ -0,0 +1,25 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+using System;
+using System.Collections.Generic;
+
+namespace osu.Game.Migrations
+{
+    public partial class AddBeatmapOnlineIDUniqueConstraint : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateIndex(
+                name: "IX_BeatmapInfo_OnlineBeatmapID",
+                table: "BeatmapInfo",
+                column: "OnlineBeatmapID",
+                unique: true);
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropIndex(
+                name: "IX_BeatmapInfo_OnlineBeatmapID",
+                table: "BeatmapInfo");
+        }
+    }
+}

osu.Game/Migrations/OsuDbContextModelSnapshot.cs

@@ -103,6 +103,9 @@ namespace osu.Game.Migrations
 
                     b.HasIndex("MetadataID");
 
+                    b.HasIndex("OnlineBeatmapID")
+                        .IsUnique();
+
                     b.HasIndex("RulesetID");
 
                     b.ToTable("BeatmapInfo");

osu.Game/Online/API/OAuth.cs

@@ -6,7 +6,7 @@ using osu.Framework.IO.Network;
 
 namespace osu.Game.Online.API
 {
-    internal class OAuth
+    public class OAuth
     {
         private readonly string clientId;
         private readonly string clientSecret;

osu.Game/Online/API/OAuthToken.cs

@@ -8,7 +8,7 @@ using Newtonsoft.Json;
 namespace osu.Game.Online.API
 {
     [Serializable]
-    internal class OAuthToken
+    public class OAuthToken
     {
         /// <summary>
         /// OAuth 2.0 access token.

osu.Game/Online/API/Requests/GetBeatmapSetsResponse.cs

@@ -71,6 +71,9 @@ namespace osu.Game.Online.API.Requests
 
         private class GetBeatmapSetsBeatmapResponse : BeatmapMetadata
         {
+            [JsonProperty(@"id")]
+            private int onlineBeatmapID { get; set; }
+
             [JsonProperty(@"playcount")]
             private int playCount { get; set; }
 
@@ -114,6 +117,7 @@ namespace osu.Game.Online.API.Requests
                     Metadata = this,
                     Ruleset = rulesets.GetRuleset(ruleset),
                     StarDifficulty = starDifficulty,
+                    OnlineBeatmapID = onlineBeatmapID,
                     Version = version,
                     BaseDifficulty = new BeatmapDifficulty
                     {

osu.Game/Online/Multiplayer/GameType.cs

@@ -100,7 +100,7 @@ namespace osu.Game.Online.Multiplayer
         }
     }
 
-    internal class VersusRow : FillFlowContainer
+    public class VersusRow : FillFlowContainer
     {
         public VersusRow(Color4 first, Color4 second, float size)
         {

osu.Game/OsuGame.cs

@@ -109,7 +109,7 @@ namespace osu.Game
             dependencies.Cache(this);
 
             configRuleset = LocalConfig.GetBindable<int>(OsuSetting.Ruleset);
-            Ruleset.Value = RulesetStore.GetRuleset(configRuleset.Value);
+            Ruleset.Value = RulesetStore.GetRuleset(configRuleset.Value) ?? RulesetStore.AvailableRulesets.First();
             Ruleset.ValueChanged += r => configRuleset.Value = r.ID ?? 0;
         }
 
@@ -255,6 +255,22 @@ namespace osu.Game
                 };
             }
 
+            // eventually informational overlays should be displayed in a stack, but for now let's only allow one to stay open at a time.
+            var informationalOverlays = new OverlayContainer[] { beatmapSetOverlay, userProfile };
+            foreach (var overlay in informationalOverlays)
+            {
+                overlay.StateChanged += state =>
+                {
+                    if (state == Visibility.Hidden) return;
+
+                    foreach (var c in informationalOverlays)
+                    {
+                        if (c == overlay) continue;
+                        c.State = Visibility.Hidden;
+                    }
+                };
+            }
+
             settings.StateChanged += delegate
             {
                 switch (settings.State)

osu.Game/Overlays/BeatmapSet/Scores/ClickableUsername.cs

@@ -0,0 +1,62 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Users;
+using osu.Framework.Input;
+
+namespace osu.Game.Overlays.BeatmapSet.Scores
+{
+    public class ClickableUsername : OsuHoverContainer
+    {
+        private readonly OsuSpriteText text;
+        private UserProfileOverlay profile;
+
+        private User user;
+        public User User
+        {
+            get { return user; }
+            set
+            {
+                if (user == value) return;
+                user = value;
+
+                text.Text = user.Username;
+            }
+        }
+
+        public float TextSize
+        {
+            set
+            {
+                if (text.TextSize == value) return;
+                text.TextSize = value;
+            }
+            get { return text.TextSize; }
+        }
+
+        public ClickableUsername()
+        {
+            AutoSizeAxes = Axes.Both;
+            Child = text = new OsuSpriteText
+            {
+                Font = @"Exo2.0-BoldItalic",
+            };
+        }
+
+        [BackgroundDependencyLoader(true)]
+        private void load(UserProfileOverlay profile)
+        {
+            this.profile = profile;
+        }
+
+        protected override bool OnClick(InputState state)
+        {
+            profile?.ShowUser(user);
+            return true;
+        }
+    }
+}

osu.Game/Overlays/BeatmapSet/Scores/DrawableScore.cs

@@ -0,0 +1,141 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using OpenTK;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Input;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Online.API.Requests;
+using osu.Game.Overlays.Profile.Sections.Ranks;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.UI;
+using osu.Game.Screens.Select.Leaderboards;
+using osu.Game.Users;
+
+namespace osu.Game.Overlays.BeatmapSet.Scores
+{
+    public class DrawableScore : Container
+    {
+        private const int fade_duration = 100;
+        private const float side_margin = 20;
+
+        private readonly Box background;
+
+        public DrawableScore(int index, OnlineScore score)
+        {
+            ScoreModsContainer modsContainer;
+
+            RelativeSizeAxes = Axes.X;
+            Height = 30;
+            CornerRadius = 3;
+            Masking = true;
+            Children = new Drawable[]
+            {
+                background = new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Alpha = 0,
+                },
+                new OsuSpriteText
+                {
+                    Anchor = Anchor.CentreLeft,
+                    Origin = Anchor.CentreLeft,
+                    Text = $"#{index + 1}",
+                    Font = @"Exo2.0-RegularItalic",
+                    Margin = new MarginPadding { Left = side_margin }
+                },
+                new DrawableFlag(score.User.Country?.FlagName)
+                {
+                    Anchor = Anchor.CentreLeft,
+                    Origin = Anchor.CentreLeft,
+                    Size = new Vector2(30, 20),
+                    Margin = new MarginPadding { Left = 60 }
+                },
+                new ClickableUsername
+                {
+                    Anchor = Anchor.CentreLeft,
+                    Origin = Anchor.CentreLeft,
+                    User = score.User,
+                    Margin = new MarginPadding { Left = 100 }
+                },
+                modsContainer = new ScoreModsContainer
+                {
+                    Anchor = Anchor.CentreLeft,
+                    Origin = Anchor.CentreLeft,
+                    AutoSizeAxes = Axes.Y,
+                    RelativeSizeAxes = Axes.X,
+                    Width = 0.06f,
+                    RelativePositionAxes = Axes.X,
+                    X = 0.42f
+                },
+                new DrawableRank(score.Rank)
+                {
+                    Anchor = Anchor.CentreLeft,
+                    Origin = Anchor.CentreLeft,
+                    Size = new Vector2(30, 20),
+                    FillMode = FillMode.Fit,
+                    RelativePositionAxes = Axes.X,
+                    X = 0.55f
+                },
+                new OsuSpriteText
+                {
+                    Anchor = Anchor.CentreLeft,
+                    Origin = Anchor.CentreRight,
+                    Text = $@"{score.TotalScore:N0}",
+                    Font = @"Venera",
+                    RelativePositionAxes = Axes.X,
+                    X = 0.75f,
+                    FixedWidth = true,
+                },
+                new OsuSpriteText
+                {
+                    Anchor = Anchor.CentreLeft,
+                    Origin = Anchor.CentreRight,
+                    Text = $@"{score.Accuracy:P2}",
+                    Font = @"Exo2.0-RegularItalic",
+                    RelativePositionAxes = Axes.X,
+                    X = 0.85f
+                },
+                new OsuSpriteText
+                {
+                    Anchor = Anchor.CentreRight,
+                    Origin = Anchor.CentreRight,
+                    Text = $"{score.Statistics["300"]}/{score.Statistics["100"]}/{score.Statistics["50"]}",
+                    Font = @"Exo2.0-RegularItalic",
+                    Margin = new MarginPadding { Right = side_margin }
+                },
+            };
+
+            foreach (Mod mod in score.Mods)
+                modsContainer.Add(new ModIcon(mod)
+                {
+                    AutoSizeAxes = Axes.Both,
+                    Scale = new Vector2(0.35f),
+                });
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            background.Colour = colours.Gray4;
+        }
+
+        protected override bool OnHover(InputState state)
+        {
+            background.FadeIn(fade_duration, Easing.OutQuint);
+            return base.OnHover(state);
+        }
+
+        protected override void OnHoverLost(InputState state)
+        {
+            background.FadeOut(fade_duration, Easing.OutQuint);
+            base.OnHoverLost(state);
+        }
+
+        protected override bool OnClick(InputState state) => true;
+    }
+}

osu.Game/Overlays/BeatmapSet/Scores/DrawableTopScore.cs

@@ -0,0 +1,243 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using OpenTK;
+using OpenTK.Graphics;
+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.Framework.Input;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Online.API.Requests;
+using osu.Game.Overlays.Profile.Sections.Ranks;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.UI;
+using osu.Game.Screens.Select.Leaderboards;
+using osu.Game.Users;
+
+namespace osu.Game.Overlays.BeatmapSet.Scores
+{
+    public class DrawableTopScore : Container
+    {
+        private const float fade_duration = 100;
+        private const float height = 200;
+        private const float avatar_size = 80;
+        private const float margin = 10;
+
+        private readonly Box background;
+        private readonly Box bottomBackground;
+        private readonly Box middleLine;
+        private readonly UpdateableAvatar avatar;
+        private readonly DrawableFlag flag;
+        private readonly ClickableUsername username;
+        private readonly OsuSpriteText rankText;
+        private readonly OsuSpriteText date;
+        private readonly DrawableRank rank;
+        private readonly InfoColumn totalScore;
+        private readonly InfoColumn accuracy;
+        private readonly InfoColumn statistics;
+        private readonly ScoreModsContainer modsContainer;
+
+        private OnlineScore score;
+        public OnlineScore Score
+        {
+            get { return score; }
+            set
+            {
+                if (score == value) return;
+                score = value;
+
+                avatar.User = username.User = score.User;
+                flag.FlagName = score.User.Country?.FlagName;
+                date.Text = $@"achieved {score.Date:MMM d, yyyy}";
+                rank.UpdateRank(score.Rank);
+
+                totalScore.Value = $@"{score.TotalScore:N0}";
+                accuracy.Value = $@"{score.Accuracy:P2}";
+                statistics.Value = $"{score.Statistics["300"]}/{score.Statistics["100"]}/{score.Statistics["50"]}";
+
+                modsContainer.Clear();
+                foreach (Mod mod in score.Mods)
+                    modsContainer.Add(new ModIcon(mod)
+                    {
+                        AutoSizeAxes = Axes.Both,
+                        Scale = new Vector2(0.45f),
+                    });
+            }
+        }
+
+        public DrawableTopScore()
+        {
+            RelativeSizeAxes = Axes.X;
+            Height = height;
+            CornerRadius = 5;
+            BorderThickness = 4;
+            Masking = true;
+            Children = new Drawable[]
+            {
+                background = new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Alpha = 0,
+                    AlwaysPresent = true, //used for correct border representation
+                },
+                avatar = new UpdateableAvatar
+                {
+                    Size = new Vector2(avatar_size),
+                    Masking = true,
+                    CornerRadius = 5,
+                    EdgeEffect = new EdgeEffectParameters
+                    {
+                        Type = EdgeEffectType.Shadow,
+                        Colour = Color4.Black.Opacity(0.25f),
+                        Offset = new Vector2(0, 2),
+                        Radius = 1,
+                    },
+                    Margin = new MarginPadding { Top = margin, Left = margin }
+                },
+                flag = new DrawableFlag
+                {
+                    Size = new Vector2(30, 20),
+                    Position = new Vector2(margin * 2 + avatar_size, height / 4),
+                },
+                username = new ClickableUsername
+                {
+                    Origin = Anchor.BottomLeft,
+                    TextSize = 30,
+                    Position = new Vector2(margin * 2 + avatar_size, height / 4),
+                    Margin = new MarginPadding { Bottom = 4 }
+                },
+                rankText = new OsuSpriteText
+                {
+                    Anchor = Anchor.TopRight,
+                    Origin = Anchor.BottomRight,
+                    Text = "#1",
+                    TextSize = 40,
+                    Font = @"Exo2.0-BoldItalic",
+                    Y = height / 4,
+                    Margin = new MarginPadding { Right = margin }
+                },
+                date = new OsuSpriteText
+                {
+                    Anchor = Anchor.TopRight,
+                    Origin = Anchor.TopRight,
+                    Y = height / 4,
+                    Margin = new MarginPadding { Right = margin }
+                },
+                new Container
+                {
+                    Anchor = Anchor.BottomCentre,
+                    Origin = Anchor.BottomCentre,
+                    RelativeSizeAxes = Axes.Both,
+                    Height = 0.5f,
+                    Children = new Drawable[]
+                    {
+                        bottomBackground = new Box { RelativeSizeAxes = Axes.Both },
+                        middleLine = new Box
+                        {
+                            RelativeSizeAxes = Axes.X,
+                            Height = 1,
+                        },
+                        rank = new DrawableRank(ScoreRank.F)
+                        {
+                            Origin = Anchor.BottomLeft,
+                            Size = new Vector2(avatar_size, 40),
+                            FillMode = FillMode.Fit,
+                            Y = height / 4,
+                            Margin = new MarginPadding { Left = margin }
+                        },
+                        new FillFlowContainer<InfoColumn>
+                        {
+                            Origin = Anchor.BottomLeft,
+                            AutoSizeAxes = Axes.Both,
+                            Position = new Vector2(height / 2, height / 4),
+                            Direction = FillDirection.Horizontal,
+                            Spacing = new Vector2(15, 0),
+                            Children = new[]
+                            {
+                                totalScore = new InfoColumn("Score"),
+                                accuracy = new InfoColumn("Accuracy"),
+                                statistics = new InfoColumn("300/100/50"),
+                            },
+                        },
+                        modsContainer = new ScoreModsContainer
+                        {
+                            AutoSizeAxes = Axes.Y,
+                            Width = 80,
+                            Position = new Vector2(height / 2, height / 4),
+                        }
+                    }
+                },
+            };
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            background.Colour = bottomBackground.Colour = colours.Gray4;
+            middleLine.Colour = colours.Gray2;
+            date.Colour = colours.Gray9;
+            BorderColour = rankText.Colour = colours.Yellow;
+        }
+
+        protected override bool OnHover(InputState state)
+        {
+            background.FadeIn(fade_duration, Easing.OutQuint);
+            return base.OnHover(state);
+        }
+
+        protected override void OnHoverLost(InputState state)
+        {
+            background.FadeOut(fade_duration, Easing.OutQuint);
+            base.OnHoverLost(state);
+        }
+
+        private class InfoColumn : FillFlowContainer
+        {
+            private readonly OsuSpriteText headerText;
+            private readonly OsuSpriteText valueText;
+
+            public string Value
+            {
+                set
+                {
+                    if (valueText.Text == value)
+                        return;
+                    valueText.Text = value;
+                }
+                get { return valueText.Text; }
+            }
+
+            public InfoColumn(string header)
+            {
+                AutoSizeAxes = Axes.Both;
+                Direction = FillDirection.Vertical;
+                Spacing = new Vector2(0, 3);
+                Children = new Drawable[]
+                {
+                    headerText = new OsuSpriteText
+                    {
+                        TextSize = 14,
+                        Text = header,
+                        Font = @"Exo2.0-Bold",
+                    },
+                    valueText = new OsuSpriteText
+                    {
+                        TextSize = 25,
+                        Font = @"Exo2.0-RegularItalic",
+                    }
+                };
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(OsuColour colours)
+            {
+                headerText.Colour = colours.Gray9;
+            }
+        }
+    }
+}

osu.Game/Overlays/BeatmapSet/Scores/ScoresContainer.cs

@@ -0,0 +1,115 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using OpenTK;
+using OpenTK.Graphics;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Online.API.Requests;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace osu.Game.Overlays.BeatmapSet.Scores
+{
+    public class ScoresContainer : Container
+    {
+        private const int spacing = 15;
+        private const int fade_duration = 200;
+
+        private readonly FillFlowContainer flow;
+        private readonly DrawableTopScore topScore;
+        private readonly LoadingAnimation loadingAnimation;
+        private readonly Box foreground;
+
+        private bool isLoading;
+        public bool IsLoading
+        {
+            get { return isLoading; }
+            set
+            {
+                if (isLoading == value) return;
+                isLoading = value;
+
+                foreground.FadeTo(isLoading ? 1 : 0, fade_duration);
+                loadingAnimation.FadeTo(isLoading ? 1 : 0, fade_duration);
+            }
+        }
+
+        private IEnumerable<OnlineScore> scores;
+        public IEnumerable<OnlineScore> Scores
+        {
+            get { return scores; }
+            set
+            {
+                scores = value;
+                var scoresAmount = scores.Count();
+                if (scoresAmount == 0)
+                {
+                    CleanAllScores();
+                    return;
+                }
+
+                topScore.Score = scores.FirstOrDefault();
+                topScore.Show();
+
+                flow.Clear();
+
+                if (scoresAmount < 2)
+                    return;
+
+                for (int i = 1; i < scoresAmount; i++)
+                    flow.Add(new DrawableScore(i, scores.ElementAt(i)));
+            }
+        }
+
+        public ScoresContainer()
+        {
+            RelativeSizeAxes = Axes.X;
+            AutoSizeAxes = Axes.Y;
+            Children = new Drawable[]
+            {
+                new FillFlowContainer
+                {
+                    Anchor = Anchor.TopCentre,
+                    Origin = Anchor.TopCentre,
+                    RelativeSizeAxes = Axes.X,
+                    AutoSizeAxes = Axes.Y,
+                    Width = 0.95f,
+                    Direction = FillDirection.Vertical,
+                    Spacing = new Vector2(0, spacing),
+                    Margin = new MarginPadding { Vertical = spacing },
+                    Children = new Drawable[]
+                    {
+                        topScore = new DrawableTopScore(),
+                        flow = new FillFlowContainer
+                        {
+                            RelativeSizeAxes = Axes.X,
+                            AutoSizeAxes = Axes.Y,
+                            Direction = FillDirection.Vertical,
+                            Spacing = new Vector2(0, 1),
+                        },
+                    }
+                },
+                foreground = new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = Color4.Black.Opacity(0.7f),
+                    Alpha = 0,
+                },
+                loadingAnimation = new LoadingAnimation
+                {
+                    Alpha = 0,
+                },
+            };
+        }
+
+        public void CleanAllScores()
+        {
+            topScore.Hide();
+            flow.Clear();
+        }
+    }
+}

osu.Game/Overlays/BeatmapSetOverlay.cs

@@ -16,6 +16,7 @@ using osu.Game.Online.API;
 using osu.Game.Online.API.Requests;
 using osu.Game.Overlays.BeatmapSet;
 using osu.Game.Rulesets;
+using osu.Game.Overlays.BeatmapSet.Scores;
 
 namespace osu.Game.Overlays
 {
@@ -26,9 +27,11 @@ namespace osu.Game.Overlays
 
         private readonly Header header;
         private readonly Info info;
+        private readonly ScoresContainer scores;
 
         private APIAccess api;
         private RulesetStore rulesets;
+        private GetScoresRequest getScoresRequest;
 
         private readonly ScrollContainer scroll;
 
@@ -76,12 +79,38 @@ namespace osu.Game.Overlays
                         {
                             header = new Header(),
                             info = new Info(),
+                            scores = new ScoresContainer(),
                         },
                     },
                 },
             };
 
-            header.Picker.Beatmap.ValueChanged += b => info.Beatmap = b;
+            header.Picker.Beatmap.ValueChanged += b =>
+            {
+                info.Beatmap = b;
+                updateScores(b);
+            };
+        }
+
+        private void updateScores(BeatmapInfo beatmap)
+        {
+            getScoresRequest?.Cancel();
+
+            if (!beatmap.OnlineBeatmapID.HasValue)
+            {
+                scores.CleanAllScores();
+                return;
+            }
+
+            scores.IsLoading = true;
+
+            getScoresRequest = new GetScoresRequest(beatmap);
+            getScoresRequest.Success += r =>
+            {
+                scores.Scores = r.Scores;
+                scores.IsLoading = false;
+            };
+            api.Queue(getScoresRequest);
         }
 
         [BackgroundDependencyLoader]

osu.Game/Overlays/ChatOverlay.cs

@@ -58,7 +58,7 @@ namespace osu.Game.Overlays
         private readonly Box chatBackground;
         private readonly Box tabBackground;
 
-        public Bindable<double> ChatHeight { get; internal set; }
+        public Bindable<double> ChatHeight { get; set; }
 
         private readonly Container channelSelectionContainer;
         private readonly ChannelSelectionOverlay channelSelection;

osu.Game/Overlays/KeyBinding/KeyBindingRow.cs

@@ -19,7 +19,7 @@ using OpenTK.Input;
 
 namespace osu.Game.Overlays.KeyBinding
 {
-    internal class KeyBindingRow : Container, IFilterable
+    public class KeyBindingRow : Container, IFilterable
     {
         private readonly object action;
         private readonly IEnumerable<Framework.Input.Bindings.KeyBinding> bindings;

osu.Game/Overlays/KeyBinding/KeyBindingsSubsection.cs

@@ -55,7 +55,7 @@ namespace osu.Game.Overlays.KeyBinding
         }
     }
 
-    internal class ResetButton : OsuButton
+    public class ResetButton : OsuButton
     {
         [BackgroundDependencyLoader]
         private void load(OsuColour colours)

osu.Game/Overlays/LoginOverlay.cs

@@ -13,7 +13,7 @@ using osu.Game.Graphics.Cursor;
 
 namespace osu.Game.Overlays
 {
-    internal class LoginOverlay : OsuFocusedOverlayContainer
+    public class LoginOverlay : OsuFocusedOverlayContainer
     {
         private LoginSettings settingsSection;
 

osu.Game/Overlays/Mods/ModButton.cs

@@ -207,14 +207,12 @@ namespace osu.Game.Overlays.Mods
                     {
                         Origin = Anchor.BottomRight,
                         Anchor = Anchor.BottomRight,
-                        AutoSizeAxes = Axes.Both,
                         Position = new Vector2(1.5f),
                     },
                     foregroundIcon = new ModIcon(Mods[0])
                     {
                         Origin = Anchor.BottomRight,
                         Anchor = Anchor.BottomRight,
-                        AutoSizeAxes = Axes.Both,
                         Position = new Vector2(-1.5f),
                     },
                 });
@@ -225,7 +223,6 @@ namespace osu.Game.Overlays.Mods
                 {
                     Origin = Anchor.Centre,
                     Anchor = Anchor.Centre,
-                    AutoSizeAxes = Axes.Both,
                 });
             }
         }

osu.Game/Overlays/Music/FilterControl.cs

@@ -13,7 +13,7 @@ using System;
 
 namespace osu.Game.Overlays.Music
 {
-    internal class FilterControl : Container
+    public class FilterControl : Container
     {
         public readonly FilterTextBox Search;
 

osu.Game/Overlays/Music/PlaylistItem.cs

@@ -17,7 +17,7 @@ using OpenTK;
 
 namespace osu.Game.Overlays.Music
 {
-    internal class PlaylistItem : Container, IFilterable, IDraggable
+    public class PlaylistItem : Container, IFilterable, IDraggable
     {
         private const float fade_duration = 100;
 

osu.Game/Overlays/Music/PlaylistList.cs

@@ -14,7 +14,7 @@ using OpenTK;
 
 namespace osu.Game.Overlays.Music
 {
-    internal class PlaylistList : CompositeDrawable
+    public class PlaylistList : CompositeDrawable
     {
         public Action<BeatmapSetInfo> OnSelect;
 

osu.Game/Overlays/MusicController.cs

@@ -37,7 +37,7 @@ namespace osu.Game.Overlays
 
         private const float bottom_black_area_height = 55;
 
-        private Drawable currentBackground;
+        private Drawable background;
         private ProgressBar progressBar;
 
         private IconButton prevButton;
@@ -120,7 +120,7 @@ namespace osu.Game.Overlays
                             },
                             Children = new[]
                             {
-                                currentBackground = new Background(),
+                                background = new Background(),
                                 title = new OsuSpriteText
                                 {
                                     Origin = Anchor.BottomCentre,
@@ -334,6 +334,7 @@ namespace osu.Game.Overlays
 
             pendingBeatmapSwitch = Schedule(delegate
             {
+                // todo: this can likely be replaced with WorkingBeatmap.GetBeatmapAsync()
                 Task.Run(() =>
                 {
                     if (beatmap?.Beatmap == null) //this is not needed if a placeholder exists
@@ -352,29 +353,26 @@ namespace osu.Game.Overlays
                     }
                 });
 
-                playerContainer.Add(new AsyncLoadWrapper(new Background(beatmap)
+                LoadComponentAsync(new Background(beatmap) { Depth = float.MaxValue }, newBackground =>
                 {
-                    OnLoadComplete = newBackground =>
+                    switch (direction)
                     {
-                        switch (direction)
-                        {
-                            case TransformDirection.Next:
-                                newBackground.Position = new Vector2(400, 0);
-                                newBackground.MoveToX(0, 500, Easing.OutCubic);
-                                currentBackground.MoveToX(-400, 500, Easing.OutCubic);
-                                break;
-                            case TransformDirection.Prev:
-                                newBackground.Position = new Vector2(-400, 0);
-                                newBackground.MoveToX(0, 500, Easing.OutCubic);
-                                currentBackground.MoveToX(400, 500, Easing.OutCubic);
-                                break;
-                        }
-                        currentBackground.Expire();
-                        currentBackground = newBackground;
+                        case TransformDirection.Next:
+                            newBackground.Position = new Vector2(400, 0);
+                            newBackground.MoveToX(0, 500, Easing.OutCubic);
+                            background.MoveToX(-400, 500, Easing.OutCubic);
+                            break;
+                        case TransformDirection.Prev:
+                            newBackground.Position = new Vector2(-400, 0);
+                            newBackground.MoveToX(0, 500, Easing.OutCubic);
+                            background.MoveToX(400, 500, Easing.OutCubic);
+                            break;
                     }
-                })
-                {
-                    Depth = float.MaxValue,
+
+                    background.Expire();
+                    background = newBackground;
+
+                    playerContainer.Add(newBackground);
                 });
             });
         }

osu.Game/Overlays/Profile/Sections/Beatmaps/PaginatedBeatmapContainer.cs

@@ -40,7 +40,7 @@ namespace osu.Game.Overlays.Profile.Sections.Beatmaps
                 ShowMoreButton.FadeTo(sets.Count == ItemsPerPage ? 1 : 0);
                 ShowMoreLoading.Hide();
 
-                if (!sets.Any())
+                if (!sets.Any() && VisiblePages == 1)
                 {
                     MissingText.Show();
                     return;

osu.Game/Overlays/Profile/Sections/Ranks/DrawableScore.cs

@@ -1,7 +1,6 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using System.Collections.Generic;
 using OpenTK;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
@@ -10,7 +9,6 @@ using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Screens.Select.Leaderboards;
-using System.Linq;
 using osu.Framework.Localisation;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;
@@ -29,7 +27,7 @@ namespace osu.Game.Overlays.Profile.Sections.Ranks
 
         protected readonly FillFlowContainer<OsuSpriteText> Stats;
         private readonly FillFlowContainer metadata;
-        private readonly ModContainer modContainer;
+        private readonly ScoreModsContainer modsContainer;
         protected readonly Score Score;
         private readonly Box underscoreLine;
         private readonly Box coloredBackground;
@@ -103,7 +101,7 @@ namespace osu.Game.Overlays.Profile.Sections.Ranks
                                 Depth = -1,
                             },
                         },
-                        modContainer = new ModContainer
+                        modsContainer = new ScoreModsContainer
                         {
                             AutoSizeAxes = Axes.Y,
                             Anchor = Anchor.CentreRight,
@@ -165,11 +163,7 @@ namespace osu.Game.Overlays.Profile.Sections.Ranks
             });
 
             foreach (Mod mod in Score.Mods)
-                modContainer.Add(new ModIcon(mod)
-                {
-                    AutoSizeAxes = Axes.Both,
-                    Scale = new Vector2(0.5f),
-                });
+                modsContainer.Add(new ModIcon(mod) { Scale = new Vector2(0.5f) });
         }
 
         protected override bool OnClick(InputState state) => true;
@@ -188,16 +182,6 @@ namespace osu.Game.Overlays.Profile.Sections.Ranks
             base.OnHoverLost(state);
         }
 
-        private class ModContainer : FlowContainer<ModIcon>
-        {
-            protected override IEnumerable<Vector2> ComputeLayoutPositions()
-            {
-                int count = FlowingChildren.Count();
-                for (int i = 0; i < count; i++)
-                    yield return new Vector2(DrawWidth * i * (count == 1 ? 0 : 1f / (count - 1)), 0);
-            }
-        }
-
         private class MetadataContainer : OsuHoverContainer, IHasTooltip
         {
             public string TooltipText { get; set; }

osu.Game/Overlays/Profile/Sections/Ranks/PaginatedScoreContainer.cs

@@ -41,7 +41,7 @@ namespace osu.Game.Overlays.Profile.Sections.Ranks
                 ShowMoreButton.FadeTo(scores.Count == ItemsPerPage ? 1 : 0);
                 ShowMoreLoading.Hide();
 
-                if (!scores.Any())
+                if (!scores.Any() && VisiblePages == 1)
                 {
                     MissingText.Show();
                     return;

osu.Game/Overlays/Profile/Sections/Ranks/ScoreModsContainer.cs

@@ -0,0 +1,21 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using OpenTK;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.UI;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace osu.Game.Overlays.Profile.Sections.Ranks
+{
+    public class ScoreModsContainer : FlowContainer<ModIcon>
+    {
+        protected override IEnumerable<Vector2> ComputeLayoutPositions()
+        {
+            int count = FlowingChildren.Count();
+            for (int i = 0; i < count; i++)
+                yield return new Vector2(DrawWidth * i * (count == 1 ? 0 : 1f / (count - 1)), 0);
+        }
+    }
+}

osu.Game/Overlays/Settings/SettingsItem.cs

@@ -135,7 +135,7 @@ namespace osu.Game.Overlays.Settings
         private class RestoreDefaultValueButton : Box, IHasTooltip
         {
             private Bindable<T> bindable;
-            internal Bindable<T> Bindable
+            public Bindable<T> Bindable
             {
                 get { return bindable; }
                 set
@@ -185,13 +185,13 @@ namespace osu.Game.Overlays.Settings
                 UpdateState();
             }
 
-            internal void SetButtonColour(Color4 buttonColour)
+            public void SetButtonColour(Color4 buttonColour)
             {
                 this.buttonColour = buttonColour;
                 UpdateState();
             }
 
-            internal void UpdateState()
+            public void UpdateState()
             {
                 if (bindable == null)
                     return;

osu.Game/Overlays/Settings/SettingsLabel.cs

@@ -7,7 +7,7 @@ using osu.Game.Graphics;
 
 namespace osu.Game.Overlays.Settings
 {
-    internal class SettingsLabel : SettingsItem<string>
+    public class SettingsLabel : SettingsItem<string>
     {
         protected override Drawable CreateControl() => null;
 

osu.Game/Overlays/Settings/Sidebar.cs

@@ -18,8 +18,8 @@ namespace osu.Game.Overlays.Settings
     public class Sidebar : Container<SidebarButton>, IStateful<ExpandedState>
     {
         private readonly FillFlowContainer<SidebarButton> content;
-        internal const float DEFAULT_WIDTH = ToolbarButton.WIDTH;
-        internal const int EXPANDED_WIDTH = 200;
+        public const float DEFAULT_WIDTH = ToolbarButton.WIDTH;
+        public const int EXPANDED_WIDTH = 200;
 
         public event Action<ExpandedState> StateChanged;
 
@@ -137,4 +137,4 @@ namespace osu.Game.Overlays.Settings
         Contracted,
         Expanded,
     }
-}
+}

osu.Game/Overlays/SettingsOverlay.cs

@@ -20,7 +20,7 @@ namespace osu.Game.Overlays
 {
     public abstract class SettingsOverlay : OsuFocusedOverlayContainer
     {
-        internal const float CONTENT_MARGINS = 10;
+        public const float CONTENT_MARGINS = 10;
 
         public const float TRANSITION_LENGTH = 600;
 

osu.Game/Overlays/Toolbar/ToolbarChatButton.cs

@@ -6,7 +6,7 @@ using osu.Game.Graphics;
 
 namespace osu.Game.Overlays.Toolbar
 {
-    internal class ToolbarChatButton : ToolbarOverlayToggleButton
+    public class ToolbarChatButton : ToolbarOverlayToggleButton
     {
         public ToolbarChatButton()
         {
@@ -19,4 +19,4 @@ namespace osu.Game.Overlays.Toolbar
             StateContainer = chat;
         }
     }
-}
+}

osu.Game/Overlays/Toolbar/ToolbarDirectButton.cs

@@ -6,7 +6,7 @@ using osu.Game.Graphics;
 
 namespace osu.Game.Overlays.Toolbar
 {
-    internal class ToolbarDirectButton : ToolbarOverlayToggleButton
+    public class ToolbarDirectButton : ToolbarOverlayToggleButton
     {
         public ToolbarDirectButton()
         {
@@ -19,4 +19,4 @@ namespace osu.Game.Overlays.Toolbar
             StateContainer = direct;
         }
     }
-}
+}

osu.Game/Overlays/Toolbar/ToolbarHomeButton.cs

@@ -5,7 +5,7 @@ using osu.Game.Graphics;
 
 namespace osu.Game.Overlays.Toolbar
 {
-    internal class ToolbarHomeButton : ToolbarButton
+    public class ToolbarHomeButton : ToolbarButton
     {
         public ToolbarHomeButton()
         {
@@ -14,4 +14,4 @@ namespace osu.Game.Overlays.Toolbar
             TooltipSub = "Return to the main menu";
         }
     }
-}
+}

osu.Game/Overlays/Toolbar/ToolbarModeSelector.cs

@@ -14,7 +14,7 @@ using osu.Game.Rulesets;
 
 namespace osu.Game.Overlays.Toolbar
 {
-    internal class ToolbarModeSelector : Container
+    public class ToolbarModeSelector : Container
     {
         private const float padding = 10;
 

osu.Game/Overlays/Toolbar/ToolbarMusicButton.cs

@@ -6,7 +6,7 @@ using osu.Game.Graphics;
 
 namespace osu.Game.Overlays.Toolbar
 {
-    internal class ToolbarMusicButton : ToolbarOverlayToggleButton
+    public class ToolbarMusicButton : ToolbarOverlayToggleButton
     {
         public ToolbarMusicButton()
         {
@@ -19,4 +19,4 @@ namespace osu.Game.Overlays.Toolbar
             StateContainer = music;
         }
     }
-}
+}

osu.Game/Overlays/Toolbar/ToolbarNotificationButton.cs

@@ -7,7 +7,7 @@ using osu.Game.Graphics;
 
 namespace osu.Game.Overlays.Toolbar
 {
-    internal class ToolbarNotificationButton : ToolbarOverlayToggleButton
+    public class ToolbarNotificationButton : ToolbarOverlayToggleButton
     {
         protected override Anchor TooltipAnchor => Anchor.TopRight;
 
@@ -24,4 +24,4 @@ namespace osu.Game.Overlays.Toolbar
             StateContainer = notificationOverlay;
         }
     }
-}
+}

osu.Game/Overlays/Toolbar/ToolbarOverlayToggleButton.cs

@@ -9,7 +9,7 @@ using osu.Game.Graphics;
 
 namespace osu.Game.Overlays.Toolbar
 {
-    internal class ToolbarOverlayToggleButton : ToolbarButton
+    public class ToolbarOverlayToggleButton : ToolbarButton
     {
         private readonly Box stateBackground;
 

osu.Game/Overlays/Toolbar/ToolbarSettingsButton.cs

@@ -6,7 +6,7 @@ using osu.Game.Graphics;
 
 namespace osu.Game.Overlays.Toolbar
 {
-    internal class ToolbarSettingsButton : ToolbarOverlayToggleButton
+    public class ToolbarSettingsButton : ToolbarOverlayToggleButton
     {
         public ToolbarSettingsButton()
         {
@@ -21,4 +21,4 @@ namespace osu.Game.Overlays.Toolbar
             StateContainer = settings;
         }
     }
-}
+}

osu.Game/Overlays/Toolbar/ToolbarSocialButton.cs

@@ -6,7 +6,7 @@ using osu.Game.Graphics;
 
 namespace osu.Game.Overlays.Toolbar
 {
-    internal class ToolbarSocialButton : ToolbarOverlayToggleButton
+    public class ToolbarSocialButton : ToolbarOverlayToggleButton
     {
         public ToolbarSocialButton()
         {
@@ -19,4 +19,4 @@ namespace osu.Game.Overlays.Toolbar
             StateContainer = chat;
         }
     }
-}
+}

osu.Game/Overlays/Toolbar/ToolbarUserArea.cs

@@ -9,7 +9,7 @@ using OpenTK;
 
 namespace osu.Game.Overlays.Toolbar
 {
-    internal class ToolbarUserArea : Container
+    public class ToolbarUserArea : Container
     {
         public LoginOverlay LoginOverlay;
         private ToolbarUserButton button;

osu.Game/Overlays/Toolbar/ToolbarUserButton.cs

@@ -12,7 +12,7 @@ using OpenTK.Graphics;
 
 namespace osu.Game.Overlays.Toolbar
 {
-    internal class ToolbarUserButton : ToolbarButton, IOnlineComponent
+    public class ToolbarUserButton : ToolbarButton, IOnlineComponent
     {
         private readonly UpdateableAvatar avatar;
 

osu.Game/Rulesets/Judgements/Judgement.cs

@@ -20,12 +20,12 @@ namespace osu.Game.Rulesets.Judgements
         /// <summary>
         /// The combo prior to this judgement occurring.
         /// </summary>
-        internal int ComboAtJudgement;
+        public int ComboAtJudgement;
 
         /// <summary>
         /// The highest combo achieved prior to this judgement occurring.
         /// </summary>
-        internal int HighestComboAtJudgement;
+        public int HighestComboAtJudgement;
 
         /// <summary>
         /// Whether a successful hit occurred.
@@ -41,7 +41,7 @@ namespace osu.Game.Rulesets.Judgements
         /// The offset from a perfect hit at which this judgement occurred.
         /// Populated when added via <see cref="DrawableHitObject{TObject}.AddJudgement"/>.
         /// </summary>
-        public double TimeOffset { get; internal set; }
+        public double TimeOffset { get; set; }
 
         /// <summary>
         /// Whether the <see cref="Result"/> should affect the combo portion of the score.

osu.Game/Rulesets/Mods/IApplicableMod.cs

@@ -1,22 +0,0 @@
-// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.UI;
-
-namespace osu.Game.Rulesets.Mods
-{
-    /// <summary>
-    /// An interface for mods that are applied to a RulesetContainer.
-    /// </summary>
-    /// <typeparam name="TObject">The type of HitObject the RulesetContainer contains.</typeparam>
-    public interface IApplicableMod<TObject>
-        where TObject : HitObject
-    {
-        /// <summary>
-        /// Applies the mod to a RulesetContainer.
-        /// </summary>
-        /// <param name="rulesetContainer">The RulesetContainer to apply the mod to.</param>
-        void ApplyToRulesetContainer(RulesetContainer<TObject> rulesetContainer);
-    }
-}

osu.Game/Rulesets/Mods/IApplicableToHitObject.cs

@@ -0,0 +1,20 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Rulesets.Objects;
+
+namespace osu.Game.Rulesets.Mods
+{
+    /// <summary>
+    /// An interface for <see cref="Mod"/>s that can be applied to <see cref="HitObject"/>s.
+    /// </summary>
+    public interface IApplicableToHitObject<in TObject>
+        where TObject : HitObject
+    {
+        /// <summary>
+        /// Applies this <see cref="IApplicableToHitObject{TObject}"/> to a <see cref="HitObject"/>.
+        /// </summary>
+        /// <param name="hitObject">The <see cref="HitObject"/> to apply to.</param>
+        void ApplyToHitObject(TObject hitObject);
+    }
+}

osu.Game/Rulesets/Mods/IApplicableToRulesetContainer.cs

@@ -0,0 +1,21 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.UI;
+
+namespace osu.Game.Rulesets.Mods
+{
+    /// <summary>
+    /// An interface for <see cref="Mod"/>s that can be applied to <see cref="RulesetContainer"/>s.
+    /// </summary>
+    public interface IApplicableToRulesetContainer<TObject>
+        where TObject : HitObject
+    {
+        /// <summary>
+        /// Applies this <see cref="IApplicableToRulesetContainer{TObject}"/> to a <see cref="RulesetContainer{TObject}"/>.
+        /// </summary>
+        /// <param name="rulesetContainer">The <see cref="RulesetContainer{TObject}"/> to apply to.</param>
+        void ApplyToRulesetContainer(RulesetContainer<TObject> rulesetContainer);
+    }
+}

osu.Game/Rulesets/Mods/IApplicableToScoreProcessor.cs

@@ -0,0 +1,15 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Rulesets.Scoring;
+
+namespace osu.Game.Rulesets.Mods
+{
+    /// <summary>
+    /// An interface for mods that make general adjustments to score processor.
+    /// </summary>
+    public interface IApplicableToScoreProcessor
+    {
+        void ApplyToScoreProcessor(ScoreProcessor scoreProcessor);
+    }
+}

osu.Game/Rulesets/Mods/ModAutoplay.cs

@@ -10,7 +10,7 @@ using osu.Game.Rulesets.UI;
 
 namespace osu.Game.Rulesets.Mods
 {
-    public abstract class ModAutoplay<T> : ModAutoplay, IApplicableMod<T>
+    public abstract class ModAutoplay<T> : ModAutoplay, IApplicableToRulesetContainer<T>
         where T : HitObject
     {
         protected abstract Score CreateReplayScore(Beatmap<T> beatmap);
@@ -30,4 +30,4 @@ namespace osu.Game.Rulesets.Mods
         public override double ScoreMultiplier => 0;
         public override Type[] IncompatibleMods => new[] { typeof(ModRelax), typeof(ModSuddenDeath), typeof(ModNoFail) };
     }
-}
+}

osu.Game/Rulesets/Mods/ModPerfect.cs

@@ -1,6 +1,8 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using osu.Game.Rulesets.Scoring;
+
 namespace osu.Game.Rulesets.Mods
 {
     public abstract class ModPerfect : ModSuddenDeath
@@ -8,5 +10,7 @@ namespace osu.Game.Rulesets.Mods
         public override string Name => "Perfect";
         public override string ShortenedName => "PF";
         public override string Description => "SS or quit.";
+
+        protected override bool FailCondition(ScoreProcessor scoreProcessor) => scoreProcessor.Accuracy.Value != 1;
     }
-}
+}

osu.Game/Rulesets/Mods/ModSuddenDeath.cs

@@ -3,10 +3,11 @@
 
 using System;
 using osu.Game.Graphics;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Mods
 {
-    public abstract class ModSuddenDeath : Mod
+    public abstract class ModSuddenDeath : Mod, IApplicableToScoreProcessor
     {
         public override string Name => "Sudden Death";
         public override string ShortenedName => "SD";
@@ -16,5 +17,12 @@ namespace osu.Game.Rulesets.Mods
         public override double ScoreMultiplier => 1;
         public override bool Ranked => true;
         public override Type[] IncompatibleMods => new[] { typeof(ModNoFail), typeof(ModRelax), typeof(ModAutoplay) };
+
+        public void ApplyToScoreProcessor(ScoreProcessor scoreProcessor)
+        {
+            scoreProcessor.FailConditions += FailCondition;
+        }
+
+        protected virtual bool FailCondition(ScoreProcessor scoreProcessor) => scoreProcessor.Combo.Value == 0;
     }
-}
+}

osu.Game/Rulesets/Objects/Legacy/Catch/ConvertHitObjectParser.cs

@@ -11,7 +11,7 @@ namespace osu.Game.Rulesets.Objects.Legacy.Catch
     /// <summary>
     /// A HitObjectParser to parse legacy osu!catch Beatmaps.
     /// </summary>
-    internal class ConvertHitObjectParser : Legacy.ConvertHitObjectParser
+    public class ConvertHitObjectParser : Legacy.ConvertHitObjectParser
     {
         protected override HitObject CreateHit(Vector2 position, bool newCombo)
         {

osu.Game/Rulesets/Objects/Legacy/ConvertHitObjectParser.cs

@@ -15,7 +15,7 @@ namespace osu.Game.Rulesets.Objects.Legacy
     /// <summary>
     /// A HitObjectParser to parse legacy Beatmaps.
     /// </summary>
-    internal abstract class ConvertHitObjectParser : HitObjectParser
+    public abstract class ConvertHitObjectParser : HitObjectParser
     {
         public override HitObject Parse(string text)
         {

osu.Game/Rulesets/Objects/Legacy/Mania/ConvertHitObjectParser.cs

@@ -11,7 +11,7 @@ namespace osu.Game.Rulesets.Objects.Legacy.Mania
     /// <summary>
     /// A HitObjectParser to parse legacy osu!mania Beatmaps.
     /// </summary>
-    internal class ConvertHitObjectParser : Legacy.ConvertHitObjectParser
+    public class ConvertHitObjectParser : Legacy.ConvertHitObjectParser
     {
         protected override HitObject CreateHit(Vector2 position, bool newCombo)
         {

osu.Game/Rulesets/Objects/Legacy/Osu/ConvertHitObjectParser.cs

@@ -11,7 +11,7 @@ namespace osu.Game.Rulesets.Objects.Legacy.Osu
     /// <summary>
     /// A HitObjectParser to parse legacy osu! Beatmaps.
     /// </summary>
-    internal class ConvertHitObjectParser : Legacy.ConvertHitObjectParser
+    public class ConvertHitObjectParser : Legacy.ConvertHitObjectParser
     {
         protected override HitObject CreateHit(Vector2 position, bool newCombo)
         {

osu.Game/Rulesets/Objects/Legacy/Taiko/ConvertHitObjectParser.cs

@@ -11,7 +11,7 @@ namespace osu.Game.Rulesets.Objects.Legacy.Taiko
     /// <summary>
     /// A HitObjectParser to parse legacy osu!taiko Beatmaps.
     /// </summary>
-    internal class ConvertHitObjectParser : Legacy.ConvertHitObjectParser
+    public class ConvertHitObjectParser : Legacy.ConvertHitObjectParser
     {
         protected override HitObject CreateHit(Vector2 position, bool newCombo)
         {

osu.Game/Rulesets/Ruleset.cs

@@ -47,7 +47,7 @@ namespace osu.Game.Rulesets
         /// <returns></returns>
         public abstract RulesetContainer CreateRulesetContainerWith(WorkingBeatmap beatmap, bool isForCurrentRuleset);
 
-        public abstract DifficultyCalculator CreateDifficultyCalculator(Beatmap beatmap);
+        public abstract DifficultyCalculator CreateDifficultyCalculator(Beatmap beatmap, Mod[] mods = null);
 
         public virtual Drawable CreateIcon() => new SpriteIcon { Icon = FontAwesome.fa_question_circle };
 

osu.Game/Rulesets/Scoring/ScoreProcessor.cs

@@ -31,6 +31,11 @@ namespace osu.Game.Rulesets.Scoring
         /// </summary>
         public event Action<Judgement> NewJudgement;
 
+        /// <summary>
+        /// Additional conditions on top of <see cref="DefaultFailCondition"/> that cause a failing state.
+        /// </summary>
+        public event Func<ScoreProcessor, bool> FailConditions;
+
         /// <summary>
         /// The current total score.
         /// </summary>
@@ -72,9 +77,9 @@ namespace osu.Game.Rulesets.Scoring
         public virtual bool HasFailed { get; private set; }
 
         /// <summary>
-        /// The conditions for failing.
+        /// The default conditions for failing.
         /// </summary>
-        protected virtual bool FailCondition => Health.Value == Health.MinValue;
+        protected virtual bool DefaultFailCondition => Health.Value == Health.MinValue;
 
         protected ScoreProcessor()
         {
@@ -121,7 +126,10 @@ namespace osu.Game.Rulesets.Scoring
         /// </summary>
         protected void UpdateFailed()
         {
-            if (HasFailed || !FailCondition)
+            if (HasFailed)
+                return;
+
+            if (!DefaultFailCondition && FailConditions?.Invoke(this) != true)
                 return;
 
             if (Failed?.Invoke() != false)
@@ -216,8 +224,8 @@ namespace osu.Game.Rulesets.Scoring
             OnNewJudgement(judgement);
             updateScore();
 
-            NotifyNewJudgement(judgement);
             UpdateFailed();
+            NotifyNewJudgement(judgement);
         }
 
         protected void RemoveJudgement(Judgement judgement)

osu.Game/Rulesets/Timing/LinearScrollingContainer.cs

@@ -8,7 +8,7 @@ namespace osu.Game.Rulesets.Timing
     /// <summary>
     /// A <see cref="ScrollingContainer"/> which scrolls linearly relative to the <see cref="MultiplierControlPoint"/> start time.
     /// </summary>
-    internal class LinearScrollingContainer : ScrollingContainer
+    public class LinearScrollingContainer : ScrollingContainer
     {
         private readonly MultiplierControlPoint controlPoint;
 

osu.Game/Rulesets/UI/ModIcon.cs

@@ -18,7 +18,7 @@ namespace osu.Game.Rulesets.UI
         private readonly SpriteIcon modIcon;
         private readonly SpriteIcon background;
 
-        private const float background_size = 80;
+        private const float size = 80;
 
         public FontAwesome Icon
         {
@@ -38,23 +38,25 @@ namespace osu.Game.Rulesets.UI
 
             TooltipText = mod.Name;
 
+            Size = new Vector2(size);
+
             Children = new Drawable[]
             {
                 background = new SpriteIcon
                 {
                     Origin = Anchor.Centre,
                     Anchor = Anchor.Centre,
-                    Size = new Vector2(background_size),
+                    Size = new Vector2(size),
                     Icon = FontAwesome.fa_osu_mod_bg,
+                    Y = -6.5f,
                     Shadow = true,
                 },
                 modIcon = new SpriteIcon
                 {
-                    Origin = Anchor.TopCentre,
-                    Anchor = Anchor.TopCentre,
+                    Origin = Anchor.Centre,
+                    Anchor = Anchor.Centre,
                     Colour = OsuColour.Gray(84),
-                    Size = new Vector2(background_size - 35),
-                    Y = 25,
+                    Size = new Vector2(size - 35),
                     Icon = mod.Icon
                 },
             };

osu.Game/Rulesets/UI/Playfield.cs

@@ -20,7 +20,7 @@ namespace osu.Game.Rulesets.UI
         /// </summary>
         public HitObjectContainer HitObjects { get; protected set; }
 
-        internal Container<Drawable> ScaledContent;
+        public Container<Drawable> ScaledContent;
 
         /// <summary>
         /// Whether we are currently providing the local user a gameplay cursor.

osu.Game/Rulesets/UI/RulesetContainer.cs

@@ -61,7 +61,7 @@ namespace osu.Game.Rulesets.UI
         /// A visual representation of a <see cref="Rulesets.Ruleset"/>.
         /// </summary>
         /// <param name="ruleset">The ruleset being repesented.</param>
-        internal RulesetContainer(Ruleset ruleset)
+        protected RulesetContainer(Ruleset ruleset)
         {
             Ruleset = ruleset;
         }
@@ -212,7 +212,11 @@ namespace osu.Game.Rulesets.UI
             if (mods == null)
                 return;
 
-            foreach (var mod in mods.OfType<IApplicableMod<TObject>>())
+            foreach (var mod in mods.OfType<IApplicableToHitObject<TObject>>())
+                foreach (var obj in Beatmap.HitObjects)
+                    mod.ApplyToHitObject(obj);
+
+            foreach (var mod in mods.OfType<IApplicableToRulesetContainer<TObject>>())
                 mod.ApplyToRulesetContainer(this);
         }
 

osu.Game/Screens/Backgrounds/BackgroundScreenBeatmap.cs

@@ -32,9 +32,7 @@ namespace osu.Game.Screens.Backgrounds
 
                 Schedule(() =>
                 {
-                    var newBackground = new BeatmapBackground(beatmap);
-
-                    LoadComponentAsync(newBackground, delegate
+                    LoadComponentAsync(new BeatmapBackground(beatmap), b =>
                     {
                         float newDepth = 0;
                         if (background != null)
@@ -45,8 +43,8 @@ namespace osu.Game.Screens.Backgrounds
                             background.Expire();
                         }
 
-                        newBackground.Depth = newDepth;
-                        Add(background = newBackground);
+                        b.Depth = newDepth;
+                        Add(background = b);
                         background.BlurSigma = blurTarget;
                     });
                 });

osu.Game/Screens/Charts/ChartInfo.cs

@@ -3,7 +3,7 @@
 
 namespace osu.Game.Screens.Charts
 {
-    internal class ChartInfo : ScreenWhiteBox
+    public class ChartInfo : ScreenWhiteBox
     {
     }
 }

osu.Game/Screens/Charts/ChartListing.cs

@@ -6,7 +6,7 @@ using System.Collections.Generic;
 
 namespace osu.Game.Screens.Charts
 {
-    internal class ChartListing : ScreenWhiteBox
+    public class ChartListing : ScreenWhiteBox
     {
         protected override IEnumerable<Type> PossibleChildren => new[] {
                 typeof(ChartInfo)

osu.Game/Screens/Direct/OnlineListing.cs

@@ -3,7 +3,7 @@
 
 namespace osu.Game.Screens.Direct
 {
-    internal class OnlineListing : ScreenWhiteBox
+    public class OnlineListing : ScreenWhiteBox
     {
     }
 }

osu.Game/Screens/Edit/Components/BottomBarContainer.cs

@@ -0,0 +1,50 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Allocation;
+using osu.Framework.Audio.Track;
+using osu.Framework.Configuration;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Beatmaps;
+using osu.Game.Graphics;
+
+namespace osu.Game.Screens.Edit.Components
+{
+    public class BottomBarContainer : Container
+    {
+        private const float corner_radius = 5;
+        private const float contents_padding = 15;
+
+        public readonly Bindable<WorkingBeatmap> Beatmap = new Bindable<WorkingBeatmap>();
+        protected Track Track => Beatmap.Value.Track;
+
+        private readonly Drawable background;
+        private readonly Container content;
+
+        protected override Container<Drawable> Content => content;
+
+        public BottomBarContainer()
+        {
+            Masking = true;
+            CornerRadius = corner_radius;
+
+            InternalChildren = new[]
+            {
+                background = new Box { RelativeSizeAxes = Axes.Both },
+                content = new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Padding = new MarginPadding { Horizontal = contents_padding },
+                }
+            };
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            background.Colour = colours.Gray1;
+        }
+    }
+}

osu.Game/Screens/Edit/Components/PlaybackControl.cs

@@ -0,0 +1,154 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using OpenTK;
+using OpenTK.Graphics;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Input;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterface;
+
+namespace osu.Game.Screens.Edit.Components
+{
+    public class PlaybackControl : BottomBarContainer
+    {
+        private readonly IconButton playButton;
+
+        public PlaybackControl()
+        {
+            PlaybackTabControl tabs;
+
+            Children = new Drawable[]
+            {
+                playButton = new IconButton
+                {
+                    Anchor = Anchor.CentreLeft,
+                    Origin = Anchor.Centre,
+                    Scale = new Vector2(1.4f),
+                    IconScale = new Vector2(1.4f),
+                    Icon = FontAwesome.fa_play_circle_o,
+                    Action = togglePause,
+                    Padding = new MarginPadding { Left = 20 }
+                },
+                new OsuSpriteText
+                {
+                    Origin = Anchor.BottomLeft,
+                    Text = "Playback Speed",
+                    RelativePositionAxes = Axes.Y,
+                    Y = 0.5f,
+                    Padding = new MarginPadding { Left = 45 }
+                },
+                new Container
+                {
+                    Anchor = Anchor.BottomLeft,
+                    Origin = Anchor.BottomLeft,
+                    RelativeSizeAxes = Axes.Both,
+                    Height = 0.5f,
+                    Padding = new MarginPadding { Left = 45 },
+                    Child = tabs = new PlaybackTabControl(),
+                }
+            };
+
+            tabs.Current.ValueChanged += newValue => Track.Tempo.Value = newValue;
+        }
+
+        private void togglePause()
+        {
+            if (Track.IsRunning)
+                Track.Stop();
+            else
+                Track.Start();
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            playButton.Icon = Track.IsRunning ? FontAwesome.fa_pause_circle_o : FontAwesome.fa_play_circle_o;
+        }
+
+        private class PlaybackTabControl : OsuTabControl<double>
+        {
+            private static readonly double[] tempo_values = { 0.5, 0.75, 1 };
+
+            protected override TabItem<double> CreateTabItem(double value) => new PlaybackTabItem(value);
+
+            protected override Dropdown<double> CreateDropdown() => null;
+
+            public PlaybackTabControl()
+            {
+                RelativeSizeAxes = Axes.Both;
+                TabContainer.Spacing = Vector2.Zero;
+
+                tempo_values.ForEach(AddItem);
+            }
+
+            public class PlaybackTabItem : TabItem<double>
+            {
+                private const float fade_duration = 200;
+
+                private readonly OsuSpriteText text;
+                private readonly OsuSpriteText textBold;
+
+                public PlaybackTabItem(double value) : base(value)
+                {
+                    RelativeSizeAxes = Axes.Both;
+
+                    Width = 1f / tempo_values.Length;
+
+                    Children = new Drawable[]
+                    {
+                        text = new OsuSpriteText
+                        {
+                            Origin = Anchor.TopCentre,
+                            Anchor = Anchor.TopCentre,
+                            Text = $"{value:0%}",
+                            TextSize = 14,
+                        },
+                        textBold = new OsuSpriteText
+                        {
+                            Origin = Anchor.TopCentre,
+                            Anchor = Anchor.TopCentre,
+                            Text = $"{value:0%}",
+                            TextSize = 14,
+                            Font = @"Exo2.0-Bold",
+                            Alpha = 0,
+                        },
+                    };
+                }
+
+                private Color4 hoveredColour;
+                private Color4 normalColour;
+
+                [BackgroundDependencyLoader]
+                private void load(OsuColour colours)
+                {
+                    text.Colour = normalColour = colours.YellowDarker;
+                    textBold.Colour = hoveredColour = colours.Yellow;
+                }
+
+                protected override bool OnHover(InputState state)
+                {
+                    updateState();
+                    return true;
+                }
+
+                protected override void OnHoverLost(InputState state) => updateState();
+                protected override void OnActivated() => updateState();
+                protected override void OnDeactivated() => updateState();
+
+                private void updateState()
+                {
+                    text.FadeColour(Active || IsHovered ? hoveredColour : normalColour, fade_duration, Easing.OutQuint);
+                    text.FadeTo(Active ? 0 : 1, fade_duration, Easing.OutQuint);
+                    textBold.FadeTo(Active ? 1 : 0, fade_duration, Easing.OutQuint);
+                }
+            }
+        }
+    }
+}

osu.Game/Screens/Edit/Components/TimeInfoContainer.cs

@@ -0,0 +1,38 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Graphics;
+using osu.Game.Graphics.Sprites;
+using System;
+
+namespace osu.Game.Screens.Edit.Components
+{
+    public class TimeInfoContainer : BottomBarContainer
+    {
+        private const int count_duration = 150;
+
+        private readonly OsuSpriteText trackTimer;
+
+        public TimeInfoContainer()
+        {
+            Children = new Drawable[]
+            {
+                trackTimer = new OsuSpriteText
+                {
+                    Origin = Anchor.BottomLeft,
+                    RelativePositionAxes = Axes.Y,
+                    TextSize = 22,
+                    FixedWidth = true,
+                    Y = 0.5f,
+                }
+            };
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            trackTimer.Text = TimeSpan.FromMilliseconds(Track.CurrentTime).ToString(@"mm\:ss\:fff");
+        }
+    }
+}

osu.Game/Screens/Edit/Components/Timelines/Summary/Parts/BookmarkPart.cs

@@ -11,7 +11,7 @@ namespace osu.Game.Screens.Edit.Components.Timelines.Summary.Parts
     /// <summary>
     /// The part of the timeline that displays bookmarks.
     /// </summary>
-    internal class BookmarkPart : TimelinePart
+    public class BookmarkPart : TimelinePart
     {
         protected override void LoadBeatmap(WorkingBeatmap beatmap)
         {

osu.Game/Screens/Edit/Components/Timelines/Summary/Parts/BreakPart.cs

@@ -12,7 +12,7 @@ namespace osu.Game.Screens.Edit.Components.Timelines.Summary.Parts
     /// <summary>
     /// The part of the timeline that displays breaks in the song.
     /// </summary>
-    internal class BreakPart : TimelinePart
+    public class BreakPart : TimelinePart
     {
         protected override void LoadBeatmap(WorkingBeatmap beatmap)
         {

osu.Game/Screens/Edit/Components/Timelines/Summary/Parts/ControlPointPart.cs

@@ -14,7 +14,7 @@ namespace osu.Game.Screens.Edit.Components.Timelines.Summary.Parts
     /// <summary>
     /// The part of the timeline that displays the control points.
     /// </summary>
-    internal class ControlPointPart : TimelinePart
+    public class ControlPointPart : TimelinePart
     {
         protected override void LoadBeatmap(WorkingBeatmap beatmap)
         {

osu.Game/Screens/Edit/Components/Timelines/Summary/Parts/MarkerPart.cs

@@ -15,7 +15,7 @@ namespace osu.Game.Screens.Edit.Components.Timelines.Summary.Parts
     /// <summary>
     /// The part of the timeline that displays the current position of the song.
     /// </summary>
-    internal class MarkerPart : TimelinePart
+    public class MarkerPart : TimelinePart
     {
         private readonly Drawable marker;
 

osu.Game/Screens/Edit/Components/Timelines/Summary/Parts/TimelinePart.cs

@@ -13,7 +13,7 @@ namespace osu.Game.Screens.Edit.Components.Timelines.Summary.Parts
     /// <summary>
     /// Represents a part of the summary timeline..
     /// </summary>
-    internal abstract class TimelinePart : CompositeDrawable
+    public abstract class TimelinePart : CompositeDrawable
     {
         public Bindable<WorkingBeatmap> Beatmap = new Bindable<WorkingBeatmap>();
 

osu.Game/Screens/Edit/Components/Timelines/Summary/SummaryTimeline.cs

@@ -3,11 +3,9 @@
 
 using OpenTK;
 using osu.Framework.Allocation;
-using osu.Framework.Configuration;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
-using osu.Game.Beatmaps;
 using osu.Game.Graphics;
 using osu.Game.Screens.Edit.Components.Timelines.Summary.Parts;
 
@@ -16,83 +14,64 @@ namespace osu.Game.Screens.Edit.Components.Timelines.Summary
     /// <summary>
     /// The timeline that sits at the bottom of the editor.
     /// </summary>
-    public class SummaryTimeline : CompositeDrawable
+    public class SummaryTimeline : BottomBarContainer
     {
-        private const float corner_radius = 5;
-        private const float contents_padding = 15;
-
-        public Bindable<WorkingBeatmap> Beatmap = new Bindable<WorkingBeatmap>();
-
-        private readonly Drawable background;
-
         private readonly Drawable timelineBar;
 
         public SummaryTimeline()
         {
-            Masking = true;
-            CornerRadius = corner_radius;
-
             TimelinePart markerPart, controlPointPart, bookmarkPart, breakPart;
 
-            InternalChildren = new[]
+            Children = new[]
             {
-                background = new Box { RelativeSizeAxes = Axes.Both },
-                new Container
+                markerPart = new MarkerPart { RelativeSizeAxes = Axes.Both },
+                controlPointPart = new ControlPointPart
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.BottomCentre,
+                    RelativeSizeAxes = Axes.Both,
+                    Height = 0.35f
+                },
+                bookmarkPart = new BookmarkPart
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.TopCentre,
+                    RelativeSizeAxes = Axes.Both,
+                    Height = 0.35f
+                },
+                timelineBar = new Container
                 {
                     RelativeSizeAxes = Axes.Both,
-                    Padding = new MarginPadding { Left = contents_padding, Right = contents_padding },
-                    Children = new[]
+                    Children = new Drawable[]
                     {
-                        markerPart = new MarkerPart { RelativeSizeAxes = Axes.Both },
-                        controlPointPart = new ControlPointPart
+                        new Circle
                         {
-                            Anchor = Anchor.Centre,
-                            Origin = Anchor.BottomCentre,
-                            RelativeSizeAxes = Axes.Both,
-                            Height = 0.35f
+                            Anchor = Anchor.CentreLeft,
+                            Origin = Anchor.CentreRight,
+                            Size = new Vector2(5)
                         },
-                        bookmarkPart = new BookmarkPart
+                        new Box
                         {
-                            Anchor = Anchor.Centre,
-                            Origin = Anchor.TopCentre,
-                            RelativeSizeAxes = Axes.Both,
-                            Height = 0.35f
+                            Anchor = Anchor.CentreLeft,
+                            Origin = Anchor.CentreLeft,
+                            RelativeSizeAxes = Axes.X,
+                            Height = 1,
+                            EdgeSmoothness = new Vector2(0, 1),
                         },
-                        timelineBar = new Container
+                        new Circle
                         {
-                            RelativeSizeAxes = Axes.Both,
-                            Children = new Drawable[]
-                            {
-                                new Circle
-                                {
-                                    Anchor = Anchor.CentreLeft,
-                                    Origin = Anchor.CentreRight,
-                                    Size = new Vector2(5)
-                                },
-                                new Box
-                                {
-                                    Anchor = Anchor.CentreLeft,
-                                    Origin = Anchor.CentreLeft,
-                                    RelativeSizeAxes = Axes.X,
-                                    Height = 1,
-                                    EdgeSmoothness = new Vector2(0, 1),
-                                },
-                                new Circle
-                                {
-                                    Anchor = Anchor.CentreRight,
-                                    Origin = Anchor.CentreLeft,
-                                    Size = new Vector2(5)
-                                },
-                            }
+                            Anchor = Anchor.CentreRight,
+                            Origin = Anchor.CentreLeft,
+                            Size = new Vector2(5)
                         },
-                        breakPart = new BreakPart
-                        {
-                            Anchor = Anchor.Centre,
-                            Origin = Anchor.Centre,
-                            RelativeSizeAxes = Axes.Both,
-                            Height = 0.25f
-                        }
                     }
+                },
+                breakPart = new BreakPart
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.Both,
+                    Height = 0.25f
                 }
             };
 
@@ -105,7 +84,6 @@ namespace osu.Game.Screens.Edit.Components.Timelines.Summary
         [BackgroundDependencyLoader]
         private void load(OsuColour colours)
         {
-            background.Colour = colours.Gray1;
             timelineBar.Colour = colours.Gray5;
         }
     }

osu.Game/Screens/Edit/Components/Timelines/Summary/Visualisations/DurationVisualisation.cs

@@ -10,7 +10,7 @@ namespace osu.Game.Screens.Edit.Components.Timelines.Summary.Visualisations
     /// <summary>
     /// Represents a spanning point on a timeline part.
     /// </summary>
-    internal class DurationVisualisation : Container
+    public class DurationVisualisation : Container
     {
         protected DurationVisualisation(double startTime, double endTime)
         {

osu.Game/Screens/Edit/Components/Timelines/Summary/Visualisations/PointVisualisation.cs

@@ -10,7 +10,7 @@ namespace osu.Game.Screens.Edit.Components.Timelines.Summary.Visualisations
     /// <summary>
     /// Represents a singular point on a timeline part.
     /// </summary>
-    internal class PointVisualisation : Box
+    public class PointVisualisation : Box
     {
         protected PointVisualisation(double startTime)
         {

osu.Game/Screens/Edit/Editor.cs

@@ -10,13 +10,13 @@ using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics;
 using osu.Game.Screens.Edit.Menus;
 using osu.Game.Screens.Edit.Components.Timelines.Summary;
-using OpenTK;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics.UserInterface;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Screens.Edit.Screens;
 using osu.Game.Screens.Edit.Screens.Compose;
 using osu.Game.Screens.Edit.Screens.Design;
+using osu.Game.Screens.Edit.Components;
 
 namespace osu.Game.Screens.Edit
 {
@@ -34,7 +34,9 @@ namespace osu.Game.Screens.Edit
         public Editor()
         {
             EditorMenuBar menuBar;
+            TimeInfoContainer timeInfo;
             SummaryTimeline timeline;
+            PlaybackControl playback;
 
             Children = new[]
             {
@@ -84,30 +86,47 @@ namespace osu.Game.Screens.Edit
                         new Container
                         {
                             RelativeSizeAxes = Axes.Both,
-                            Padding = new MarginPadding { Top = 5, Bottom = 5, Left = 10, Right = 10 },
-                            Child = new FillFlowContainer
+                            Padding = new MarginPadding { Vertical = 5, Horizontal = 10 },
+                            Child = new GridContainer
                             {
-                                Name = "Bottom bar",
                                 RelativeSizeAxes = Axes.Both,
-                                Direction = FillDirection.Horizontal,
-                                Spacing = new Vector2(10, 0),
-                                Children = new[]
+                                ColumnDimensions = new[]
                                 {
-                                    timeline = new SummaryTimeline
+                                    new Dimension(GridSizeMode.Absolute, 220),
+                                    new Dimension(),
+                                    new Dimension(GridSizeMode.Absolute, 220)
+                                },
+                                Content = new[]
+                                {
+                                    new Drawable[]
                                     {
-                                        Anchor = Anchor.Centre,
-                                        Origin = Anchor.Centre,
-                                        RelativeSizeAxes = Axes.Both,
-                                        Width = 0.65f
-                                    }
+                                        new Container
+                                        {
+                                            RelativeSizeAxes = Axes.Both,
+                                            Padding = new MarginPadding { Right = 10 },
+                                            Child = timeInfo = new TimeInfoContainer { RelativeSizeAxes = Axes.Both },
+                                        },
+                                        timeline = new SummaryTimeline
+                                        {
+                                            RelativeSizeAxes = Axes.Both,
+                                        },
+                                        new Container
+                                        {
+                                            RelativeSizeAxes = Axes.Both,
+                                            Padding = new MarginPadding { Left = 10 },
+                                            Child = playback = new PlaybackControl { RelativeSizeAxes = Axes.Both },
+                                        }
+                                    },
                                 }
-                            }
+                            },
                         }
                     }
                 },
             };
 
+            timeInfo.Beatmap.BindTo(Beatmap);
             timeline.Beatmap.BindTo(Beatmap);
+            playback.Beatmap.BindTo(Beatmap);
             menuBar.Mode.ValueChanged += onModeChanged;
         }
 
@@ -154,7 +173,11 @@ namespace osu.Game.Screens.Edit
         protected override bool OnExiting(Screen next)
         {
             Background.FadeColour(Color4.White, 500);
-            Beatmap.Value.Track?.Start();
+            if (Beatmap.Value.Track != null)
+            {
+                Beatmap.Value.Track.Tempo.Value = 1;
+                Beatmap.Value.Track.Start();
+            }
             return base.OnExiting(next);
         }
     }

osu.Game/Screens/Edit/Screens/Design/Design.cs

@@ -9,7 +9,7 @@ using OpenTK.Graphics;
 
 namespace osu.Game.Screens.Edit.Screens.Design
 {
-    internal class Design : EditorScreen
+    public class Design : EditorScreen
     {
         public Design()
         {

osu.Game/Screens/Menu/ButtonSystem.cs

@@ -17,6 +17,7 @@ using OpenTK.Graphics;
 using OpenTK.Input;
 using osu.Framework.Audio.Sample;
 using osu.Framework.Audio;
+using osu.Framework.Threading;
 
 namespace osu.Game.Screens.Menu
 {
@@ -38,10 +39,10 @@ namespace osu.Game.Screens.Menu
         private readonly FlowContainerWithOrigin buttonFlow;
 
         //todo: make these non-internal somehow.
-        internal const float BUTTON_AREA_HEIGHT = 100;
+        public const float BUTTON_AREA_HEIGHT = 100;
 
-        internal const float BUTTON_WIDTH = 140f;
-        internal const float WEDGE_WIDTH = 20;
+        public const float BUTTON_WIDTH = 140f;
+        public const float WEDGE_WIDTH = 20;
 
         private OsuLogo logo;
 
@@ -55,6 +56,8 @@ namespace osu.Game.Screens.Menu
 
                 // osuLogo.SizeForFlow relies on loading to be complete.
                 buttonFlow.Position = new Vector2(WEDGE_WIDTH * 2 - (BUTTON_WIDTH + this.logo.SizeForFlow / 4), 0);
+
+                updateLogoState();
             }
         }
 
@@ -217,29 +220,17 @@ namespace osu.Game.Screens.Menu
                 if (state == MenuState.TopLevel)
                     buttonArea.FinishTransforms(true);
 
+                updateLogoState(lastState);
+
                 using (buttonArea.BeginDelayedSequence(lastState == MenuState.Initial ? 150 : 0, true))
                 {
                     switch (state)
                     {
                         case MenuState.Exit:
                         case MenuState.Initial:
-                            trackingPosition = false;
-
                             buttonAreaBackground.ScaleTo(Vector2.One, 500, Easing.Out);
                             buttonArea.FadeOut(300);
 
-                            logo?.Delay(150)
-                                .Schedule(() =>
-                                {
-                                    toolbar?.Hide();
-
-                                    logo.ClearTransforms(targetMember: nameof(Position));
-                                    logo.RelativePositionAxes = Axes.Both;
-
-                                    logo.MoveTo(new Vector2(0.5f), 800, Easing.OutExpo);
-                                    logo.ScaleTo(1, 800, Easing.OutExpo);
-                                });
-
                             foreach (Button b in buttonsTopLevel)
                                 b.State = ButtonState.Contracted;
 
@@ -252,33 +243,6 @@ namespace osu.Game.Screens.Menu
                         case MenuState.TopLevel:
                             buttonAreaBackground.ScaleTo(Vector2.One, 200, Easing.Out);
 
-                            logo.ClearTransforms(targetMember: nameof(Position));
-                            logo.RelativePositionAxes = Axes.None;
-
-                            trackingPosition = true;
-
-                            switch (lastState)
-                            {
-                                case MenuState.Initial:
-                                    logo.ScaleTo(0.5f, 200, Easing.In);
-
-                                    trackingPosition = false;
-
-                                    logo
-                                        .MoveTo(iconTrackingPosition, lastState == MenuState.EnteringMode ? 0 : 200, Easing.In)
-                                        .OnComplete(o =>
-                                        {
-                                            trackingPosition = true;
-
-                                            o.Impact();
-                                            toolbar?.Show();
-                                        });
-                                    break;
-                                default:
-                                    logo.ScaleTo(0.5f, 200, Easing.OutQuint);
-                                    break;
-                            }
-
                             buttonArea.FadeIn(300);
 
                             foreach (Button b in buttonsTopLevel)
@@ -297,8 +261,6 @@ namespace osu.Game.Screens.Menu
                         case MenuState.EnteringMode:
                             buttonAreaBackground.ScaleTo(new Vector2(2, 0), 300, Easing.InSine);
 
-                            trackingPosition = true;
-
                             buttonsTopLevel.ForEach(b => b.ContractStyle = 1);
                             buttonsPlay.ForEach(b => b.ContractStyle = 1);
                             backButton.ContractStyle = 1;
@@ -320,9 +282,69 @@ namespace osu.Game.Screens.Menu
             }
         }
 
-        private Vector2 iconTrackingPosition => logo.Parent.ToLocalSpace(iconFacade.ScreenSpaceDrawQuad.Centre);
+        private ScheduledDelegate logoDelayedAction;
 
-        private bool trackingPosition;
+        private void updateLogoState(MenuState lastState = MenuState.Initial)
+        {
+            if (logo == null) return;
+
+            logoDelayedAction?.Cancel();
+
+            switch (state)
+            {
+                case MenuState.Exit:
+                case MenuState.Initial:
+                    logoTracking = false;
+
+                    logoDelayedAction = Scheduler.AddDelayed(() =>
+                    {
+                        toolbar?.Hide();
+
+                        logo.ClearTransforms(targetMember: nameof(Position));
+                        logo.RelativePositionAxes = Axes.Both;
+
+                        logo.MoveTo(new Vector2(0.5f), 800, Easing.OutExpo);
+                        logo.ScaleTo(1, 800, Easing.OutExpo);
+                    }, 150);
+
+                    break;
+                case MenuState.TopLevel:
+                case MenuState.Play:
+                    logo.ClearTransforms(targetMember: nameof(Position));
+                    logo.RelativePositionAxes = Axes.None;
+
+                    switch (lastState)
+                    {
+                        case MenuState.TopLevel: // coming from toplevel to play
+                        case MenuState.Initial:
+                            logoTracking = false;
+                            logo.ScaleTo(0.5f, 200, Easing.In);
+
+                            logo.MoveTo(logoTrackingPosition, lastState == MenuState.EnteringMode ? 0 : 200, Easing.In);
+
+                            logoDelayedAction = Scheduler.AddDelayed(() =>
+                            {
+                                logoTracking = true;
+
+                                logo.Impact();
+                                toolbar?.Show();
+                            }, 200);
+                            break;
+                        default:
+                            logoTracking = true;
+                            logo.ScaleTo(0.5f, 200, Easing.OutQuint);
+                            break;
+                    }
+                    break;
+                case MenuState.EnteringMode:
+                    logoTracking = true;
+                    break;
+            }
+        }
+
+        private Vector2 logoTrackingPosition => logo.Parent.ToLocalSpace(iconFacade.ScreenSpaceDrawQuad.Centre);
+
+        private bool logoTracking;
 
         protected override void Update()
         {
@@ -333,8 +355,8 @@ namespace osu.Game.Screens.Menu
 
             if (logo != null)
             {
-                if (trackingPosition)
-                    logo.Position = iconTrackingPosition;
+                if (logoTracking)
+                    logo.Position = logoTrackingPosition;
 
                 iconFacade.Width = logo.SizeForFlow * 0.5f;
             }

osu.Game/Screens/Menu/Intro.cs

@@ -25,7 +25,7 @@ namespace osu.Game.Screens.Menu
         /// <summary>
         /// Whether we have loaded the menu previously.
         /// </summary>
-        internal bool DidLoadMenu;
+        public bool DidLoadMenu;
 
         private MainMenu mainMenu;
         private SampleChannel welcome;

osu.Game/Screens/Menu/LogoVisualisation.cs

@@ -85,12 +85,11 @@ namespace osu.Game.Screens.Menu
 
         private void updateAmplitudes()
         {
-            var track = beatmap.Value.Track;
+            var track = beatmap.Value.TrackLoaded ? beatmap.Value.Track : null;
+            var effect = beatmap.Value.BeatmapLoaded ? beatmap.Value.Beatmap.ControlPointInfo.EffectPointAt(track?.CurrentTime ?? Time.Current) : null;
 
             float[] temporalAmplitudes = track?.CurrentAmplitudes.FrequencyAmplitudes ?? new float[256];
 
-            var effect = beatmap.Value.Beatmap.ControlPointInfo.EffectPointAt(track?.CurrentTime ?? Time.Current);
-
             for (int i = 0; i < bars_per_visualiser; i++)
             {
                 if (track?.IsRunning ?? false)

osu.Game/Screens/Menu/OsuLogo.cs

@@ -226,7 +226,7 @@ namespace osu.Game.Screens.Menu
         /// </summary>
         /// <param name="action">The animation to be performed</param>
         /// <param name="waitForPrevious">If true, the new animation is delayed until all previous transforms finish. If false, existing transformed are cleared.</param>
-        internal void AppendAnimatingAction(Action action, bool waitForPrevious)
+        public void AppendAnimatingAction(Action action, bool waitForPrevious)
         {
             Action runnableAction = () =>
             {

osu.Game/Screens/Multiplayer/Lobby.cs

@@ -6,7 +6,7 @@ using System.Collections.Generic;
 
 namespace osu.Game.Screens.Multiplayer
 {
-    internal class Lobby : ScreenWhiteBox
+    public class Lobby : ScreenWhiteBox
     {
         protected override IEnumerable<Type> PossibleChildren => new[] {
                 typeof(MatchCreate),

osu.Game/Screens/Multiplayer/Match.cs

@@ -12,7 +12,7 @@ using osu.Framework.Graphics;
 
 namespace osu.Game.Screens.Multiplayer
 {
-    internal class Match : ScreenWhiteBox
+    public class Match : ScreenWhiteBox
     {
         protected override IEnumerable<Type> PossibleChildren => new[] {
             typeof(MatchSongSelect),

osu.Game/Screens/Multiplayer/MatchCreate.cs

@@ -6,7 +6,7 @@ using System.Collections.Generic;
 
 namespace osu.Game.Screens.Multiplayer
 {
-    internal class MatchCreate : ScreenWhiteBox
+    public class MatchCreate : ScreenWhiteBox
     {
         protected override IEnumerable<Type> PossibleChildren => new[] {
                 typeof(Match)

osu.Game/Screens/Play/HUD/ModDisplay.cs

@@ -55,11 +55,7 @@ namespace osu.Game.Screens.Play.HUD
                 iconsContainer.Clear();
                 foreach (Mod mod in mods)
                 {
-                    iconsContainer.Add(new ModIcon(mod)
-                    {
-                        AutoSizeAxes = Axes.Both,
-                        Scale = new Vector2(0.6f),
-                    });
+                    iconsContainer.Add(new ModIcon(mod) { Scale = new Vector2(0.6f) });
                 }
 
                 if (IsLoaded)

osu.Game/Screens/Play/Player.cs

@@ -227,10 +227,15 @@ namespace osu.Game.Screens.Play
             // Bind ScoreProcessor to ourselves
             scoreProcessor.AllJudged += onCompletion;
             scoreProcessor.Failed += onFail;
+
+            foreach (var mod in Beatmap.Value.Mods.Value.OfType<IApplicableToScoreProcessor>())
+                mod.ApplyToScoreProcessor(scoreProcessor);
         }
 
         private void applyRateFromMods()
         {
+            if (adjustableSourceClock == null) return;
+
             adjustableSourceClock.Rate = 1;
             foreach (var mod in Beatmap.Value.Mods.Value.OfType<IApplicableToClock>())
                 mod.ApplyToClock(adjustableSourceClock);