Merge remote-tracking branch 'upstream/master' into taiko-hitsounds-fix

# Conflicts:
#	osu.Game/Audio/SampleInfo.cs

osu.Game/Rulesets/Edit/HitObjectComposer.cs

@@ -12,6 +12,7 @@ using osu.Framework.Graphics.Shapes;
 using osu.Framework.Logging;
 using osu.Framework.Timing;
 using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Edit.Layers.Selection;
 using osu.Game.Rulesets.Edit.Tools;
 using osu.Game.Rulesets.UI;
 using osu.Game.Screens.Edit.Screens.Compose.RadioButtons;
@@ -77,7 +78,8 @@ namespace osu.Game.Rulesets.Edit
                                     Alpha = 0,
                                     AlwaysPresent = true,
                                 },
-                                rulesetContainer
+                                rulesetContainer,
+                                new SelectionLayer(rulesetContainer.Playfield)
                             }
                         }
                     },

osu.Game/Rulesets/Edit/Layers/Selection/Handle.cs

@@ -0,0 +1,105 @@
+// 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;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Primitives;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Input;
+using osu.Game.Graphics;
+using OpenTK;
+using OpenTK.Graphics;
+
+namespace osu.Game.Rulesets.Edit.Layers.Selection
+{
+    /// <summary>
+    /// Represents a marker visible on the border of a <see cref="HandleContainer"/> which exposes
+    /// properties that are used to resize a <see cref="HitObjectSelectionBox"/>.
+    /// </summary>
+    public class Handle : CompositeDrawable
+    {
+        private const float marker_size = 10;
+
+        /// <summary>
+        /// Invoked when this <see cref="Handle"/> requires the current drag rectangle.
+        /// </summary>
+        public Func<RectangleF> GetDragRectangle;
+
+        /// <summary>
+        /// Invoked when this <see cref="Handle"/> wants to update the drag rectangle.
+        /// </summary>
+        public Action<RectangleF> UpdateDragRectangle;
+
+        /// <summary>
+        /// Invoked when this <see cref="Handle"/> has finished updates to the drag rectangle.
+        /// </summary>
+        public Action FinishDrag;
+
+        private Color4 normalColour;
+        private Color4 hoverColour;
+
+        public Handle()
+        {
+            Size = new Vector2(marker_size);
+
+            InternalChild = new CircularContainer
+            {
+                RelativeSizeAxes = Axes.Both,
+                Masking = true,
+                Child = new Box { RelativeSizeAxes = Axes.Both }
+            };
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            Colour = normalColour = colours.Yellow;
+            hoverColour = colours.YellowDarker;
+        }
+
+        protected override bool OnDragStart(InputState state) => true;
+
+        protected override bool OnDrag(InputState state)
+        {
+            var currentRectangle = GetDragRectangle();
+
+            float left = currentRectangle.Left;
+            float right = currentRectangle.Right;
+            float top = currentRectangle.Top;
+            float bottom = currentRectangle.Bottom;
+
+            // Apply modifications to the capture rectangle
+            if ((Anchor & Anchor.y0) > 0)
+                top += state.Mouse.Delta.Y;
+            else if ((Anchor & Anchor.y2) > 0)
+                bottom += state.Mouse.Delta.Y;
+
+            if ((Anchor & Anchor.x0) > 0)
+                left += state.Mouse.Delta.X;
+            else if ((Anchor & Anchor.x2) > 0)
+                right += state.Mouse.Delta.X;
+
+            UpdateDragRectangle(RectangleF.FromLTRB(left, top, right, bottom));
+            return true;
+        }
+
+        protected override bool OnDragEnd(InputState state)
+        {
+            FinishDrag();
+            return true;
+        }
+
+        protected override bool OnHover(InputState state)
+        {
+            this.FadeColour(hoverColour, 100);
+            return true;
+        }
+
+        protected override void OnHoverLost(InputState state)
+        {
+            this.FadeColour(normalColour, 100);
+        }
+    }
+}

osu.Game/Rulesets/Edit/Layers/Selection/HandleContainer.cs

@@ -0,0 +1,92 @@
+// 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;
+using System.Linq;
+using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Primitives;
+
+namespace osu.Game.Rulesets.Edit.Layers.Selection
+{
+    /// <summary>
+    /// A <see cref="CompositeDrawable"/> that has <see cref="Handle"/>s around its border.
+    /// </summary>
+    public class HandleContainer : CompositeDrawable
+    {
+        /// <summary>
+        /// Invoked when a <see cref="Handle"/> requires the current drag rectangle.
+        /// </summary>
+        public Func<RectangleF> GetDragRectangle;
+
+        /// <summary>
+        /// Invoked when a <see cref="Handle"/> wants to update the drag rectangle.
+        /// </summary>
+        public Action<RectangleF> UpdateDragRectangle;
+
+        /// <summary>
+        /// Invoked when a <see cref="Handle"/> has finished updates to the drag rectangle.
+        /// </summary>
+        public Action FinishDrag;
+
+        public HandleContainer()
+        {
+            InternalChildren = new Drawable[]
+            {
+                new Handle
+                {
+                    Anchor = Anchor.TopLeft,
+                    Origin = Anchor.Centre
+                },
+                new Handle
+                {
+                    Anchor = Anchor.TopCentre,
+                    Origin = Anchor.Centre
+                },
+                new Handle
+                {
+                    Anchor = Anchor.TopRight,
+                    Origin = Anchor.Centre
+                },
+                new Handle
+                {
+                    Anchor = Anchor.CentreLeft,
+                    Origin = Anchor.Centre
+                },
+                new Handle
+                {
+                    Anchor = Anchor.BottomLeft,
+                    Origin = Anchor.Centre
+                },
+                new Handle
+                {
+                    Anchor = Anchor.CentreRight,
+                    Origin = Anchor.Centre
+                },
+                new Handle
+                {
+                    Anchor = Anchor.BottomRight,
+                    Origin = Anchor.Centre
+                },
+                new Handle
+                {
+                    Anchor = Anchor.BottomCentre,
+                    Origin = Anchor.Centre
+                },
+                new OriginHandle
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre
+                }
+            };
+
+            InternalChildren.OfType<Handle>().ForEach(m =>
+            {
+                m.GetDragRectangle = () => GetDragRectangle();
+                m.UpdateDragRectangle = r => UpdateDragRectangle(r);
+                m.FinishDrag = () => FinishDrag();
+            });
+        }
+    }
+}

osu.Game/Rulesets/Edit/Layers/Selection/HitObjectSelectionBox.cs

@@ -0,0 +1,178 @@
+// 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;
+using System.Collections.Generic;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Primitives;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Graphics;
+using osu.Game.Rulesets.Objects.Drawables;
+using OpenTK;
+using OpenTK.Graphics;
+using osu.Framework.Configuration;
+
+namespace osu.Game.Rulesets.Edit.Layers.Selection
+{
+    /// <summary>
+    /// A box that represents a drag selection.
+    /// </summary>
+    public class HitObjectSelectionBox : CompositeDrawable
+    {
+        public readonly Bindable<SelectionInfo> Selection = new Bindable<SelectionInfo>();
+
+        /// <summary>
+        /// The <see cref="DrawableHitObject"/>s that can be selected through a drag-selection.
+        /// </summary>
+        public IEnumerable<DrawableHitObject> CapturableObjects;
+
+        private readonly Container borderMask;
+        private readonly Drawable background;
+        private readonly HandleContainer handles;
+
+        private Color4 captureFinishedColour;
+
+        private readonly Vector2 startPos;
+
+        /// <summary>
+        /// Creates a new <see cref="HitObjectSelectionBox"/>.
+        /// </summary>
+        /// <param name="startPos">The point at which the drag was initiated, in the parent's coordinates.</param>
+        public HitObjectSelectionBox(Vector2 startPos)
+        {
+            this.startPos = startPos;
+
+            InternalChildren = new Drawable[]
+            {
+                new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Padding = new MarginPadding(-1),
+                    Child = borderMask = new Container
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Masking = true,
+                        BorderColour = Color4.White,
+                        BorderThickness = 2,
+                        MaskingSmoothness = 1,
+                        Child = background = new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Alpha = 0.1f,
+                            AlwaysPresent = true
+                        },
+                    }
+                },
+                handles = new HandleContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Alpha = 0,
+                    GetDragRectangle = () => dragRectangle,
+                    UpdateDragRectangle = updateDragRectangle,
+                    FinishDrag = FinishCapture
+                }
+            };
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            captureFinishedColour = colours.Yellow;
+        }
+
+        /// <summary>
+        /// The secondary corner of the drag selection box. A rectangle will be fit between the starting position and this value.
+        /// </summary>
+        public Vector2 DragEndPosition { set => updateDragRectangle(RectangleF.FromLTRB(startPos.X, startPos.Y, value.X, value.Y)); }
+
+        private RectangleF dragRectangle;
+        private void updateDragRectangle(RectangleF rectangle)
+        {
+            dragRectangle = rectangle;
+
+            Position = new Vector2(
+                Math.Min(rectangle.Left, rectangle.Right),
+                Math.Min(rectangle.Top, rectangle.Bottom));
+
+            Size = new Vector2(
+                Math.Max(rectangle.Left, rectangle.Right) - Position.X,
+                Math.Max(rectangle.Top, rectangle.Bottom) - Position.Y);
+        }
+
+        private readonly List<DrawableHitObject> capturedHitObjects = new List<DrawableHitObject>();
+
+        /// <summary>
+        /// Processes hitobjects to determine which ones are captured by the drag selection.
+        /// Captured hitobjects will be enclosed by the drag selection upon <see cref="FinishCapture"/>.
+        /// </summary>
+        public void BeginCapture()
+        {
+            capturedHitObjects.Clear();
+
+            foreach (var obj in CapturableObjects)
+            {
+                if (!obj.IsAlive || !obj.IsPresent)
+                    continue;
+
+                if (ScreenSpaceDrawQuad.Contains(obj.SelectionPoint))
+                    capturedHitObjects.Add(obj);
+            }
+        }
+
+        /// <summary>
+        /// Encloses hitobjects captured through <see cref="BeginCapture"/> in the drag selection box.
+        /// </summary>
+        public void FinishCapture()
+        {
+            if (capturedHitObjects.Count == 0)
+            {
+                Hide();
+                return;
+            }
+
+            // Move the rectangle to cover the hitobjects
+            var topLeft = new Vector2(float.MaxValue, float.MaxValue);
+            var bottomRight = new Vector2(float.MinValue, float.MinValue);
+
+            foreach (var obj in capturedHitObjects)
+            {
+                topLeft = Vector2.ComponentMin(topLeft, Parent.ToLocalSpace(obj.SelectionQuad.TopLeft));
+                bottomRight = Vector2.ComponentMax(bottomRight, Parent.ToLocalSpace(obj.SelectionQuad.BottomRight));
+            }
+
+            topLeft -= new Vector2(5);
+            bottomRight += new Vector2(5);
+
+            this.MoveTo(topLeft, 200, Easing.OutQuint)
+                .ResizeTo(bottomRight - topLeft, 200, Easing.OutQuint);
+
+            dragRectangle = RectangleF.FromLTRB(topLeft.X, topLeft.Y, bottomRight.X, bottomRight.Y);
+
+            borderMask.BorderThickness = 3;
+            borderMask.FadeColour(captureFinishedColour, 200);
+
+            // Transform into markers to let the user modify the drag selection further.
+            background.Delay(50).FadeOut(200);
+            handles.FadeIn(200);
+
+            Selection.Value = new SelectionInfo
+            {
+                Objects = capturedHitObjects,
+                SelectionQuad = Parent.ToScreenSpace(dragRectangle)
+            };
+        }
+
+        private bool isActive = true;
+        public override bool HandleInput => isActive;
+
+        public override void Hide()
+        {
+            isActive = false;
+            this.FadeOut(400, Easing.OutQuint).Expire();
+
+            Selection.Value = null;
+        }
+    }
+}

osu.Game/Rulesets/Edit/Layers/Selection/OriginHandle.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.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Graphics;
+using OpenTK;
+
+namespace osu.Game.Rulesets.Edit.Layers.Selection
+{
+    /// <summary>
+    /// Represents the origin of a <see cref="HandleContainer"/>.
+    /// </summary>
+    public class OriginHandle : CompositeDrawable
+    {
+        private const float marker_size = 10;
+        private const float line_width = 2;
+
+        public OriginHandle()
+        {
+            Size = new Vector2(marker_size);
+
+            InternalChildren = new[]
+            {
+                new Box
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.X,
+                    Height = line_width
+                },
+                new Box
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.Y,
+                    Width = line_width
+                },
+            };
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            Colour = colours.Yellow;
+        }
+    }
+}

osu.Game/Rulesets/Edit/Layers/Selection/SelectionInfo.cs

@@ -0,0 +1,22 @@
+// 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 osu.Framework.Graphics.Primitives;
+using osu.Game.Rulesets.Objects.Drawables;
+
+namespace osu.Game.Rulesets.Edit.Layers.Selection
+{
+    public class SelectionInfo
+    {
+        /// <summary>
+        /// The objects that are captured by the selection.
+        /// </summary>
+        public IEnumerable<DrawableHitObject> Objects;
+
+        /// <summary>
+        /// The screen space quad of the selection box surrounding <see cref="Objects"/>.
+        /// </summary>
+        public Quad SelectionQuad;
+    }
+}

osu.Game/Rulesets/Edit/Layers/Selection/SelectionLayer.cs

@@ -0,0 +1,61 @@
+// 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.Configuration;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Input;
+using osu.Game.Rulesets.UI;
+
+namespace osu.Game.Rulesets.Edit.Layers.Selection
+{
+    public class SelectionLayer : CompositeDrawable
+    {
+        public readonly Bindable<SelectionInfo> Selection = new Bindable<SelectionInfo>();
+
+        private readonly Playfield playfield;
+
+        public SelectionLayer(Playfield playfield)
+        {
+            this.playfield = playfield;
+
+            RelativeSizeAxes = Axes.Both;
+        }
+
+        private HitObjectSelectionBox selectionBoxBox;
+
+        protected override bool OnDragStart(InputState state)
+        {
+            // Hide the previous drag box - we won't be working with it any longer
+            selectionBoxBox?.Hide();
+
+            AddInternal(selectionBoxBox = new HitObjectSelectionBox(ToLocalSpace(state.Mouse.NativeState.Position))
+            {
+                CapturableObjects = playfield.HitObjects.Objects,
+            });
+
+            Selection.BindTo(selectionBoxBox.Selection);
+
+            return true;
+        }
+
+        protected override bool OnDrag(InputState state)
+        {
+            selectionBoxBox.DragEndPosition = ToLocalSpace(state.Mouse.NativeState.Position);
+            selectionBoxBox.BeginCapture();
+            return true;
+        }
+
+        protected override bool OnDragEnd(InputState state)
+        {
+            selectionBoxBox.FinishCapture();
+            return true;
+        }
+
+        protected override bool OnClick(InputState state)
+        {
+            selectionBoxBox?.Hide();
+            return true;
+        }
+    }
+}

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

@@ -14,6 +14,8 @@ using osu.Game.Audio;
 using System.Linq;
 using osu.Game.Graphics;
 using osu.Framework.Configuration;
+using OpenTK;
+using osu.Framework.Graphics.Primitives;
 
 namespace osu.Game.Rulesets.Objects.Drawables
 {
@@ -38,6 +40,16 @@ namespace osu.Game.Rulesets.Objects.Drawables
         {
             HitObject = hitObject;
         }
+
+        /// <summary>
+        /// The screen-space point that causes this <see cref="DrawableHitObject"/> to be selected in the Editor.
+        /// </summary>
+        public virtual Vector2 SelectionPoint => ScreenSpaceDrawQuad.Centre;
+
+        /// <summary>
+        /// The screen-space quad that outlines this <see cref="DrawableHitObject"/> for selections in the Editor.
+        /// </summary>
+        public virtual Quad SelectionQuad => ScreenSpaceDrawQuad;
     }
 
     public abstract class DrawableHitObject<TObject> : DrawableHitObject
@@ -75,12 +87,23 @@ namespace osu.Game.Rulesets.Objects.Drawables
         {
             foreach (SampleInfo sample in HitObject.Samples)
             {
-                SampleChannel channel = audio.Sample.Get($@"Gameplay/{sample.Bank}-{sample.Name}");
+                if (HitObject.SoundControlPoint == null)
+                    throw new ArgumentNullException(nameof(HitObject.SoundControlPoint), $"{nameof(HitObject)} must always have an attached {nameof(HitObject.SoundControlPoint)}.");
+
+                var bank = sample.Bank;
+                if (string.IsNullOrEmpty(bank))
+                    bank = HitObject.SoundControlPoint.SampleBank;
+
+                int volume = sample.Volume;
+                if (volume == 0)
+                    volume = HitObject.SoundControlPoint.SampleVolume;
+
+                SampleChannel channel = audio.Sample.Get($@"Gameplay/{bank}-{sample.Name}");
 
                 if (channel == null)
                     continue;
 
-                channel.Volume.Value = sample.Volume;
+                channel.Volume.Value = volume;
                 Samples.Add(channel);
             }
         }

osu.Game/Rulesets/Objects/HitObject.cs

@@ -1,6 +1,10 @@
 // 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 Newtonsoft.Json;
+using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Framework.Lists;
 using osu.Game.Audio;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
@@ -30,39 +34,47 @@ namespace osu.Game.Rulesets.Objects
         /// </summary>
         public SampleInfoList Samples = new SampleInfoList();
 
+        [JsonIgnore]
+        public SoundControlPoint SoundControlPoint;
+
         /// <summary>
         /// Whether this <see cref="HitObject"/> is in Kiai time.
         /// </summary>
+        [JsonIgnore]
         public bool Kiai { get; private set; }
 
+        private readonly SortedList<HitObject> nestedHitObjects = new SortedList<HitObject>((h1, h2) => h1.StartTime.CompareTo(h2.StartTime));
+
+        [JsonIgnore]
+        public IReadOnlyList<HitObject> NestedHitObjects => nestedHitObjects;
+
         /// <summary>
         /// Applies default values to this HitObject.
         /// </summary>
         /// <param name="controlPointInfo">The control points.</param>
         /// <param name="difficulty">The difficulty settings to use.</param>
-        public virtual void ApplyDefaults(ControlPointInfo controlPointInfo, BeatmapDifficulty difficulty)
+        public void ApplyDefaults(ControlPointInfo controlPointInfo, BeatmapDifficulty difficulty)
+        {
+            ApplyDefaultsToSelf(controlPointInfo, difficulty);
+
+            nestedHitObjects.Clear();
+            CreateNestedHitObjects();
+            nestedHitObjects.ForEach(h => h.ApplyDefaults(controlPointInfo, difficulty));
+        }
+
+        protected virtual void ApplyDefaultsToSelf(ControlPointInfo controlPointInfo, BeatmapDifficulty difficulty)
         {
             SoundControlPoint soundPoint = controlPointInfo.SoundPointAt(StartTime);
             EffectControlPoint effectPoint = controlPointInfo.EffectPointAt(StartTime);
 
-            Kiai |= effectPoint.KiaiMode;
-
-            // Initialize first sample
-            Samples.ForEach(s => initializeSampleInfo(s, soundPoint));
-
-            // Initialize any repeat samples
-            var repeatData = this as IHasRepeats;
-            repeatData?.RepeatSamples?.ForEach(r => r.ForEach(s => initializeSampleInfo(s, soundPoint)));
+            Kiai = effectPoint.KiaiMode;
+            SoundControlPoint = soundPoint;
         }
 
-        private void initializeSampleInfo(SampleInfo sample, SoundControlPoint soundPoint)
+        protected virtual void CreateNestedHitObjects()
         {
-            if (sample.Volume == 0)
-                sample.Volume = soundPoint?.SampleVolume ?? 0;
-
-            // If the bank is not assigned a name, assign it from the control point
-            if (string.IsNullOrEmpty(sample.Bank))
-                sample.Bank = soundPoint?.SampleBank ?? @"normal";
         }
+
+        protected void AddNested(HitObject hitObject) => nestedHitObjects.Add(hitObject);
     }
 }

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

@@ -46,9 +46,9 @@ namespace osu.Game.Rulesets.Objects.Legacy
             throw new NotImplementedException();
         }
 
-        public override void ApplyDefaults(ControlPointInfo controlPointInfo, BeatmapDifficulty difficulty)
+        protected override void ApplyDefaultsToSelf(ControlPointInfo controlPointInfo, BeatmapDifficulty difficulty)
         {
-            base.ApplyDefaults(controlPointInfo, difficulty);
+            base.ApplyDefaultsToSelf(controlPointInfo, difficulty);
 
             TimingControlPoint timingPoint = controlPointInfo.TimingPointAt(StartTime);
             DifficultyControlPoint difficultyPoint = controlPointInfo.DifficultyPointAt(StartTime);

osu.Game/Rulesets/RulesetInfo.cs

@@ -3,12 +3,14 @@
 
 using System;
 using System.ComponentModel.DataAnnotations.Schema;
+using Newtonsoft.Json;
 
 namespace osu.Game.Rulesets
 {
     public class RulesetInfo : IEquatable<RulesetInfo>
     {
         [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
+        [JsonIgnore]
         public int? ID { get; set; }
 
         public string Name { get; set; }
@@ -17,6 +19,7 @@ namespace osu.Game.Rulesets
 
         public string InstantiationInfo { get; set; }
 
+        [JsonIgnore]
         public bool Available { get; set; }
 
         public virtual Ruleset CreateInstance() => (Ruleset)Activator.CreateInstance(Type.GetType(InstantiationInfo), this);

osu.Game/Rulesets/UI/RulesetContainer.cs

@@ -55,10 +55,11 @@ namespace osu.Game.Rulesets.UI
 
         public abstract IEnumerable<HitObject> Objects { get; }
 
+        private readonly Lazy<Playfield> playfield;
         /// <summary>
         /// The playfield.
         /// </summary>
-        public Playfield Playfield { get; protected set; }
+        public Playfield Playfield => playfield.Value;
 
         protected readonly Ruleset Ruleset;
 
@@ -69,6 +70,7 @@ namespace osu.Game.Rulesets.UI
         protected RulesetContainer(Ruleset ruleset)
         {
             Ruleset = ruleset;
+            playfield = new Lazy<Playfield>(CreatePlayfield);
         }
 
         public abstract ScoreProcessor CreateScoreProcessor();
@@ -95,6 +97,12 @@ namespace osu.Game.Rulesets.UI
             Replay = replay;
             ReplayInputManager.ReplayInputHandler = replay != null ? CreateReplayInputHandler(replay) : null;
         }
+
+        /// <summary>
+        /// Creates a Playfield.
+        /// </summary>
+        /// <returns>The Playfield.</returns>
+        protected abstract Playfield CreatePlayfield();
     }
 
     /// <summary>
@@ -198,7 +206,7 @@ namespace osu.Game.Rulesets.UI
             });
 
             AddInternal(KeyBindingInputManager);
-            KeyBindingInputManager.Add(Playfield = CreatePlayfield());
+            KeyBindingInputManager.Add(Playfield);
 
             loadObjects();
         }
@@ -286,12 +294,6 @@ namespace osu.Game.Rulesets.UI
         /// <param name="h">The HitObject to make drawable.</param>
         /// <returns>The DrawableHitObject.</returns>
         protected abstract DrawableHitObject<TObject> GetVisualRepresentation(TObject h);
-
-        /// <summary>
-        /// Creates a Playfield.
-        /// </summary>
-        /// <returns>The Playfield.</returns>
-        protected abstract Playfield CreatePlayfield();
     }
 
     /// <summary>