Merge pull request #1525 from peppy/fix-import-duplicates

Fix "unique constraints" errors during beatmap import

osu.Game.Rulesets.Catch/CatchDifficultyCalculator.cs

@@ -14,11 +14,8 @@ namespace osu.Game.Rulesets.Catch
         {
         }
 
-        protected override double CalculateInternal(Dictionary<string, string> categoryDifficulty)
-        {
-            return 0;
-        }
+        public override double Calculate(Dictionary<string, string> categoryDifficulty = null) => 0;
 
-        protected override BeatmapConverter<CatchBaseHit> CreateBeatmapConverter() => new CatchBeatmapConverter();
+        protected override BeatmapConverter<CatchBaseHit> CreateBeatmapConverter(Beatmap beatmap) => new CatchBeatmapConverter();
     }
-}
+}

osu.Game.Rulesets.Catch/CatchRuleset.cs

@@ -95,7 +95,7 @@ namespace osu.Game.Rulesets.Catch
 
         public override Drawable CreateIcon() => new SpriteIcon { Icon = FontAwesome.fa_osu_fruits_o };
 
-        public override DifficultyCalculator CreateDifficultyCalculator(Beatmap beatmap) => new CatchDifficultyCalculator(beatmap);
+        public override DifficultyCalculator CreateDifficultyCalculator(Beatmap beatmap, Mod[] mods = null) => new CatchDifficultyCalculator(beatmap);
 
         public override int LegacyID => 2;
 

osu.Game.Rulesets.Mania/ManiaDifficultyCalculator.cs

@@ -16,11 +16,8 @@ namespace osu.Game.Rulesets.Mania
         {
         }
 
-        protected override double CalculateInternal(Dictionary<string, string> categoryDifficulty)
-        {
-            return 0;
-        }
+        public override double Calculate(Dictionary<string, string> categoryDifficulty = null) => 0;
 
-        protected override BeatmapConverter<ManiaHitObject> CreateBeatmapConverter() => new ManiaBeatmapConverter(true, (int)Math.Max(1, Math.Round(Beatmap.BeatmapInfo.BaseDifficulty.CircleSize)));
+        protected override BeatmapConverter<ManiaHitObject> CreateBeatmapConverter(Beatmap beatmap) => new ManiaBeatmapConverter(true, (int)Math.Max(1, Math.Round(beatmap.BeatmapInfo.BaseDifficulty.CircleSize)));
     }
 }

osu.Game.Rulesets.Mania/ManiaRuleset.cs

@@ -107,7 +107,7 @@ namespace osu.Game.Rulesets.Mania
 
         public override Drawable CreateIcon() => new SpriteIcon { Icon = FontAwesome.fa_osu_mania_o };
 
-        public override DifficultyCalculator CreateDifficultyCalculator(Beatmap beatmap) => new ManiaDifficultyCalculator(beatmap);
+        public override DifficultyCalculator CreateDifficultyCalculator(Beatmap beatmap, Mod[] mods = null) => new ManiaDifficultyCalculator(beatmap);
 
         public override int LegacyID => 3;
 

osu.Game.Rulesets.Mania/Mods/ManiaMod.cs

@@ -86,18 +86,17 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override Type[] IncompatibleMods => new[] { typeof(ModFlashlight) };
     }
 
-    public class ManiaModRandom : Mod, IApplicableMod<ManiaHitObject>
+    public class ManiaModRandom : Mod, IApplicableToRulesetContainer<ManiaHitObject>
     {
         public override string Name => "Random";
         public override string ShortenedName => "RD";
-        public override FontAwesome Icon => FontAwesome.fa_osu_dice;
+        public override FontAwesome Icon => FontAwesome.fa_osu_dice;
         public override string Description => @"Shuffle around the notes!";
         public override double ScoreMultiplier => 1;
 
         public void ApplyToRulesetContainer(RulesetContainer<ManiaHitObject> rulesetContainer)
         {
             int availableColumns = ((ManiaRulesetContainer)rulesetContainer).AvailableColumns;
-
             var shuffledColumns = Enumerable.Range(0, availableColumns).OrderBy(item => RNG.Next()).ToList();
 
             rulesetContainer.Objects.OfType<ManiaHitObject>().ForEach(h => h.Column = shuffledColumns[h.Column]);
@@ -188,6 +187,7 @@ namespace osu.Game.Rulesets.Mania.Mods
 
             base.ApplyToRulesetContainer(rulesetContainer);
         }
+
         protected override Score CreateReplayScore(Beatmap<ManiaHitObject> beatmap) => new Score
         {
             User = new User { Username = "osu!topus!" },

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

@@ -9,7 +9,6 @@ using osu.Game.Rulesets.Osu.Objects;
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;
@@ -33,22 +32,29 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override double ScoreMultiplier => 1.06;
     }
 
-    public class OsuModHardRock : ModHardRock, IApplicableMod<OsuHitObject>
+    public class OsuModHardRock : ModHardRock, IApplicableToHitObject<OsuHitObject>
     {
         public override double ScoreMultiplier => 1.06;
         public override bool Ranked => true;
 
-        public void ApplyToRulesetContainer(RulesetContainer<OsuHitObject> rulesetContainer)
+        public void ApplyToHitObject(OsuHitObject hitObject)
+        {
+            hitObject.Position = new Vector2(hitObject.Position.X, OsuPlayfield.BASE_SIZE.Y - hitObject.Y);
+
+            var slider = hitObject as Slider;
+            if (slider == null)
+                return;
+
+            var newControlPoints = new List<Vector2>();
+            slider.ControlPoints.ForEach(c => newControlPoints.Add(new Vector2(c.X, OsuPlayfield.BASE_SIZE.Y - c.Y)));
+
+            slider.ControlPoints = newControlPoints;
+            slider.Curve?.Calculate(); // Recalculate the slider curve
+        }
+
+        public void ApplyToHitObjects(RulesetContainer<OsuHitObject> rulesetContainer)
         {
-            rulesetContainer.Objects.OfType<OsuHitObject>().ForEach(h => h.Position = new Vector2(h.Position.X, OsuPlayfield.BASE_SIZE.Y - h.Y));
-            rulesetContainer.Objects.OfType<Slider>().ForEach(s =>
-            {
-                var newControlPoints = new List<Vector2>();
-                s.ControlPoints.ForEach(c => newControlPoints.Add(new Vector2(c.X, OsuPlayfield.BASE_SIZE.Y - c.Y)));
 
-                s.ControlPoints = newControlPoints;
-                s.Curve?.Calculate(); // Recalculate the slider curve
-            });
         }
     }
 

osu.Game.Rulesets.Osu/OsuDifficulty/OsuDifficultyCalculator.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Beatmaps;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.OsuDifficulty.Preprocessing;
@@ -16,19 +17,25 @@ namespace osu.Game.Rulesets.Osu.OsuDifficulty
         private const int section_length = 400;
         private const double difficulty_multiplier = 0.0675;
 
-        public OsuDifficultyCalculator(Beatmap beatmap) : base(beatmap)
+        public OsuDifficultyCalculator(Beatmap beatmap)
+            : base(beatmap)
+        {
+        }
+
+        public OsuDifficultyCalculator(Beatmap beatmap, Mod[] mods)
+            : base(beatmap, mods)
         {
         }
 
         protected override void PreprocessHitObjects()
         {
-            foreach (OsuHitObject h in Objects)
+            foreach (OsuHitObject h in Beatmap.HitObjects)
                 (h as Slider)?.Curve?.Calculate();
         }
 
-        protected override double CalculateInternal(Dictionary<string, string> categoryDifficulty)
+        public override double Calculate(Dictionary<string, string> categoryDifficulty = null)
         {
-            OsuDifficultyBeatmap beatmap = new OsuDifficultyBeatmap(Objects);
+            OsuDifficultyBeatmap beatmap = new OsuDifficultyBeatmap(Beatmap.HitObjects);
             Skill[] skills =
             {
                 new Aim(),
@@ -67,6 +74,6 @@ namespace osu.Game.Rulesets.Osu.OsuDifficulty
             return starRating;
         }
 
-        protected override BeatmapConverter<OsuHitObject> CreateBeatmapConverter() => new OsuBeatmapConverter();
+        protected override BeatmapConverter<OsuHitObject> CreateBeatmapConverter(Beatmap beatmap) => new OsuBeatmapConverter();
     }
 }

osu.Game.Rulesets.Osu/OsuRuleset.cs

@@ -112,7 +112,7 @@ namespace osu.Game.Rulesets.Osu
 
         public override Drawable CreateIcon() => new SpriteIcon { Icon = FontAwesome.fa_osu_osu_o };
 
-        public override DifficultyCalculator CreateDifficultyCalculator(Beatmap beatmap) => new OsuDifficultyCalculator(beatmap);
+        public override DifficultyCalculator CreateDifficultyCalculator(Beatmap beatmap, Mod[] mods = null) => new OsuDifficultyCalculator(beatmap, mods);
 
         public override string Description => "osu!";
 

osu.Game.Rulesets.Taiko/TaikoDifficultyCalculator.cs

@@ -36,12 +36,12 @@ namespace osu.Game.Rulesets.Taiko
         {
         }
 
-        protected override double CalculateInternal(Dictionary<string, string> categoryDifficulty)
+        public override double Calculate(Dictionary<string, string> categoryDifficulty = null)
         {
             // Fill our custom DifficultyHitObject class, that carries additional information
             difficultyHitObjects.Clear();
 
-            foreach (var hitObject in Objects)
+            foreach (var hitObject in Beatmap.HitObjects)
                 difficultyHitObjects.Add(new TaikoHitObjectDifficulty(hitObject));
 
             // Sort DifficultyHitObjects by StartTime of the HitObjects - just to make sure.
@@ -134,6 +134,6 @@ namespace osu.Game.Rulesets.Taiko
             return difficulty;
         }
 
-        protected override BeatmapConverter<TaikoHitObject> CreateBeatmapConverter() => new TaikoBeatmapConverter(true);
+        protected override BeatmapConverter<TaikoHitObject> CreateBeatmapConverter(Beatmap beatmap) => new TaikoBeatmapConverter(true);
     }
 }

osu.Game.Rulesets.Taiko/TaikoRuleset.cs

@@ -97,7 +97,7 @@ namespace osu.Game.Rulesets.Taiko
 
         public override Drawable CreateIcon() => new SpriteIcon { Icon = FontAwesome.fa_osu_taiko_o };
 
-        public override DifficultyCalculator CreateDifficultyCalculator(Beatmap beatmap) => new TaikoDifficultyCalculator(beatmap);
+        public override DifficultyCalculator CreateDifficultyCalculator(Beatmap beatmap, Mod[] mods = null) => new TaikoDifficultyCalculator(beatmap);
 
         public override int LegacyID => 1;
 

osu.Game/Beatmaps/BeatmapManager.cs

@@ -483,7 +483,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>(),
@@ -510,16 +511,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/DummyWorkingBeatmap.cs

@@ -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

@@ -28,16 +28,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 Lazy<Beatmap>(populateBeatmap);
+            background = new Lazy<Texture>(populateBackground);
+            track = new Lazy<Track>(populateTrack);
+            waveform = new Lazy<Waveform>(populateWaveform);
         }
 
         protected abstract Beatmap GetBeatmap();
@@ -45,98 +40,72 @@ 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;
+        private readonly Lazy<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;
+        private Lazy<Texture> background;
+
+        private Texture populateBackground() => GetBackground();
+
+        public bool TrackLoaded => track.IsValueCreated;
+        public Track Track => track.Value;
+        private Lazy<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;
+        private readonly Lazy<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)
-            {
-                track?.Dispose();
-                track = null;
-            }
+            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);
         }
     }
 }

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,9 +35,12 @@ 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;

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/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/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/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/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/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/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/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/UI/RulesetContainer.cs

@@ -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/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
 {
@@ -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/Ranking/ResultsPageScore.cs

@@ -324,7 +324,7 @@ namespace osu.Game.Screens.Ranking
                 title.Colour = artist.Colour = colours.BlueDarker;
                 versionMapper.Colour = colours.Gray8;
 
-                versionMapper.Text = $"{beatmap.Version} - mapped by {beatmap.Metadata.Author}";
+                versionMapper.Text = $"{beatmap.Version} - mapped by {beatmap.Metadata.Author.Username}";
                 title.Current = localisation.GetUnicodePreference(beatmap.Metadata.TitleUnicode, beatmap.Metadata.Title);
                 artist.Current = localisation.GetUnicodePreference(beatmap.Metadata.ArtistUnicode, beatmap.Metadata.Artist);
             }

osu.Game/Screens/Select/Leaderboards/Leaderboard.cs

@@ -17,19 +17,21 @@ using osu.Game.Graphics.UserInterface;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Online.API;
 using osu.Game.Online.API.Requests;
+using System.Linq;
 
 namespace osu.Game.Screens.Select.Leaderboards
 {
     public class Leaderboard : Container
     {
         private readonly ScrollContainer scrollContainer;
-        private readonly FillFlowContainer<LeaderboardScore> scrollFlow;
+        private FillFlowContainer<LeaderboardScore> scrollFlow;
 
         public Action<Score> ScoreSelected;
 
         private readonly LoadingAnimation loading;
 
         private IEnumerable<Score> scores;
+
         public IEnumerable<Score> Scores
         {
             get { return scores; }
@@ -38,36 +40,37 @@ namespace osu.Game.Screens.Select.Leaderboards
                 scores = value;
                 getScoresRequest?.Cancel();
 
-                int i = 150;
+                scrollFlow?.FadeOut(200);
+                scrollFlow?.Expire();
+                scrollFlow = null;
+
                 if (scores == null)
-                {
-                    foreach (var c in scrollFlow.Children)
-                        c.FadeOut(i += 10);
-
-                    foreach (var c in scrollFlow.Children)
-                        c.LifetimeEnd = Time.Current + i;
-
                     return;
-                }
 
-                scrollFlow.Clear();
-
-                i = 0;
-                foreach (var s in scores)
+                // schedule because we may not be loaded yet (LoadComponentAsync complains).
+                Schedule(() =>
                 {
-                    var ls = new LeaderboardScore(s, 1 + i)
+                    LoadComponentAsync(new FillFlowContainer<LeaderboardScore>
                     {
-                        AlwaysPresent = true,
-                        Action = () => ScoreSelected?.Invoke(s),
-                        State = Visibility.Hidden,
-                    };
-                    scrollFlow.Add(ls);
+                        RelativeSizeAxes = Axes.X,
+                        AutoSizeAxes = Axes.Y,
+                        Spacing = new Vector2(0f, 5f),
+                        Padding = new MarginPadding { Top = 10, Bottom = 5 },
+                        ChildrenEnumerable = scores.Select((s, index) => new LeaderboardScore(s, index + 1) { Action = () => ScoreSelected?.Invoke(s) })
+                    }, f =>
+                    {
+                        scrollContainer.Add(scrollFlow = f);
 
-                    using (BeginDelayedSequence(i++ * 50, true))
-                        ls.Show();
-                }
+                        int i = 0;
+                        foreach (var s in f.Children)
+                        {
+                            using (s.BeginDelayedSequence(i++ * 50, true))
+                                s.Show();
+                        }
 
-                scrollContainer.ScrollTo(0f, false);
+                        scrollContainer.ScrollTo(0f, false);
+                    });
+                });
             }
         }
 
@@ -79,16 +82,6 @@ namespace osu.Game.Screens.Select.Leaderboards
                 {
                     RelativeSizeAxes = Axes.Both,
                     ScrollbarVisible = false,
-                    Children = new Drawable[]
-                    {
-                        scrollFlow = new FillFlowContainer<LeaderboardScore>
-                        {
-                            RelativeSizeAxes = Axes.X,
-                            AutoSizeAxes = Axes.Y,
-                            Spacing = new Vector2(0f, 5f),
-                            Padding = new MarginPadding { Top = 10, Bottom = 5 },
-                        },
-                    },
                 },
                 loading = new LoadingAnimation()
             };
@@ -152,6 +145,8 @@ namespace osu.Game.Screens.Select.Leaderboards
             if (!scrollContainer.IsScrolledToEnd())
                 fadeStart -= LeaderboardScore.HEIGHT;
 
+            if (scrollFlow == null) return;
+
             foreach (var c in scrollFlow.Children)
             {
                 var topY = c.ToSpaceOfOtherDrawable(Vector2.Zero, scrollFlow).Y;

osu.Game/Screens/Select/Leaderboards/LeaderboardScore.cs

@@ -2,9 +2,10 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System;
+using System.Linq;
 using OpenTK;
 using OpenTK.Graphics;
-using osu.Framework;
+using osu.Framework.Allocation;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -13,14 +14,13 @@ using osu.Framework.Input;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
-using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;
 using osu.Game.Users;
 
 namespace osu.Game.Screens.Select.Leaderboards
 {
-    public class LeaderboardScore : OsuClickableContainer, IStateful<Visibility>
+    public class LeaderboardScore : OsuClickableContainer
     {
         public static readonly float HEIGHT = 60;
 
@@ -34,72 +34,16 @@ namespace osu.Game.Screens.Select.Leaderboards
         private const float background_alpha = 0.25f;
         private const float rank_width = 30;
 
-        private readonly Box background;
-        private readonly Container content;
-        private readonly Container avatar;
-        private readonly DrawableRank scoreRank;
-        private readonly OsuSpriteText nameLabel;
-        private readonly GlowingSpriteText scoreLabel;
-        private readonly ScoreComponentLabel maxCombo;
-        private readonly ScoreComponentLabel accuracy;
-        private readonly Container flagBadgeContainer;
-        private readonly FillFlowContainer<ModIcon> modsContainer;
-
-        private Visibility state;
-
-        public Visibility State
-        {
-            get { return state; }
-            set
-            {
-                if (state == value)
-                    return;
-                state = value;
-
-                switch (state)
-                {
-                    case Visibility.Hidden:
-                        foreach (var d in new Drawable[] { avatar, nameLabel, scoreLabel, scoreRank, flagBadgeContainer, maxCombo, accuracy, modsContainer })
-                            d.FadeOut();
-
-                        Alpha = 0;
-
-                        content.MoveToY(75);
-                        avatar.MoveToX(75);
-                        nameLabel.MoveToX(150);
-                        break;
-                    case Visibility.Visible:
-                        this.FadeIn(200);
-                        content.MoveToY(0, 800, Easing.OutQuint);
-
-                        using (BeginDelayedSequence(100, true))
-                        {
-                            avatar.FadeIn(300, Easing.OutQuint);
-                            nameLabel.FadeIn(350, Easing.OutQuint);
-
-                            avatar.MoveToX(0, 300, Easing.OutQuint);
-                            nameLabel.MoveToX(0, 350, Easing.OutQuint);
-
-                            using (BeginDelayedSequence(250, true))
-                            {
-                                scoreLabel.FadeIn(200);
-                                scoreRank.FadeIn(200);
-
-                                using (BeginDelayedSequence(50, true))
-                                {
-                                    var drawables = new Drawable[] { flagBadgeContainer, maxCombo, accuracy, modsContainer, };
-                                    for (int i = 0; i < drawables.Length; i++)
-                                        drawables[i].FadeIn(100 + i * 50);
-                                }
-                            }
-                        }
-
-                        break;
-                }
-
-                StateChanged?.Invoke(State);
-            }
-        }
+        private Box background;
+        private Container content;
+        private Container avatar;
+        private DrawableRank scoreRank;
+        private OsuSpriteText nameLabel;
+        private GlowingSpriteText scoreLabel;
+        private ScoreComponentLabel maxCombo;
+        private ScoreComponentLabel accuracy;
+        private Container flagBadgeContainer;
+        private FillFlowContainer<ModIcon> modsContainer;
 
         public LeaderboardScore(Score score, int rank)
         {
@@ -108,7 +52,11 @@ namespace osu.Game.Screens.Select.Leaderboards
 
             RelativeSizeAxes = Axes.X;
             Height = HEIGHT;
+        }
 
+        [BackgroundDependencyLoader]
+        private void load()
+        {
             Children = new Drawable[]
             {
                 new Container
@@ -255,23 +203,51 @@ namespace osu.Game.Screens.Select.Leaderboards
                                     Origin = Anchor.BottomRight,
                                     AutoSizeAxes = Axes.Both,
                                     Direction = FillDirection.Horizontal,
+                                    ChildrenEnumerable = Score.Mods.Select(mod => new ModIcon(mod) { Scale = new Vector2(0.375f) })
                                 },
                             },
                         },
                     },
                 },
             };
-
-            foreach (Mod mod in Score.Mods)
-            {
-                modsContainer.Add(new ModIcon(mod) { Scale = new Vector2(0.375f) });
-            }
         }
 
-        public void ToggleVisibility() => State = State == Visibility.Visible ? Visibility.Hidden : Visibility.Visible;
+        public override void Show()
+        {
+            foreach (var d in new Drawable[] { avatar, nameLabel, scoreLabel, scoreRank, flagBadgeContainer, maxCombo, accuracy, modsContainer })
+                d.FadeOut();
 
-        public override void Hide() => State = Visibility.Hidden;
-        public override void Show() => State = Visibility.Visible;
+            Alpha = 0;
+
+            content.MoveToY(75);
+            avatar.MoveToX(75);
+            nameLabel.MoveToX(150);
+
+            this.FadeIn(200);
+            content.MoveToY(0, 800, Easing.OutQuint);
+
+            using (BeginDelayedSequence(100, true))
+            {
+                avatar.FadeIn(300, Easing.OutQuint);
+                nameLabel.FadeIn(350, Easing.OutQuint);
+
+                avatar.MoveToX(0, 300, Easing.OutQuint);
+                nameLabel.MoveToX(0, 350, Easing.OutQuint);
+
+                using (BeginDelayedSequence(250, true))
+                {
+                    scoreLabel.FadeIn(200);
+                    scoreRank.FadeIn(200);
+
+                    using (BeginDelayedSequence(50, true))
+                    {
+                        var drawables = new Drawable[] { flagBadgeContainer, maxCombo, accuracy, modsContainer, };
+                        for (int i = 0; i < drawables.Length; i++)
+                            drawables[i].FadeIn(100 + i * 50);
+                    }
+                }
+            }
+        }
 
         protected override bool OnHover(InputState state)
         {

osu.Game/osu.Game.csproj

@@ -279,6 +279,10 @@
     <Compile Include="Migrations\20171025071459_AddMissingIndexRules.Designer.cs">
       <DependentUpon>20171025071459_AddMissingIndexRules.cs</DependentUpon>
     </Compile>
+    <Compile Include="Migrations\20171119065731_AddBeatmapOnlineIDUniqueConstraint.cs" />
+    <Compile Include="Migrations\20171119065731_AddBeatmapOnlineIDUniqueConstraint.designer.cs">
+      <DependentUpon>20171119065731_AddBeatmapOnlineIDUniqueConstraint.cs</DependentUpon>
+    </Compile>
     <Compile Include="Migrations\OsuDbContextModelSnapshot.cs" />
     <Compile Include="Online\API\Requests\GetBeatmapSetRequest.cs" />
     <Compile Include="Online\API\Requests\GetBeatmapSetsResponse.cs" />
@@ -549,9 +553,10 @@
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Rulesets\Judgements\DrawableJudgement.cs" />
     <Compile Include="Rulesets\Judgements\Judgement.cs" />
-    <Compile Include="Rulesets\Mods\IApplicableMod.cs" />
     <Compile Include="Rulesets\Mods\IApplicableToClock.cs" />
     <Compile Include="Rulesets\Mods\IApplicableToDifficulty.cs" />
+    <Compile Include="Rulesets\Mods\IApplicableToHitObject.cs" />
+    <Compile Include="Rulesets\Mods\IApplicableToRulesetContainer.cs" />
     <Compile Include="Rulesets\Mods\Mod.cs" />
     <Compile Include="Rulesets\Mods\ModAutoplay.cs" />
     <Compile Include="Rulesets\Mods\ModCinema.cs" />