Fix remaining issues

osu.Game.Rulesets.Catch.Tests/CatchBeatmapConversionTest.cs

@@ -34,13 +34,16 @@ namespace osu.Game.Rulesets.Catch.Tests
                 case JuiceStream stream:
                     foreach (var nested in stream.NestedHitObjects)
                         yield return new ConvertValue((CatchHitObject)nested);
+
                     break;
                 case BananaShower shower:
                     foreach (var nested in shower.NestedHitObjects)
                         yield return new ConvertValue((CatchHitObject)nested);
+
                     break;
                 default:
                     yield return new ConvertValue((CatchHitObject)hitObject);
+
                     break;
             }
         }

osu.Game.Rulesets.Catch.Tests/TestCaseCatchPlayer.cs

@@ -8,7 +8,8 @@ namespace osu.Game.Rulesets.Catch.Tests
     [TestFixture]
     public class TestCaseCatchPlayer : Game.Tests.Visual.TestCasePlayer
     {
-        public TestCaseCatchPlayer() : base(new CatchRuleset())
+        public TestCaseCatchPlayer()
+            : base(new CatchRuleset())
         {
         }
     }

osu.Game.Rulesets.Catch/Beatmaps/CatchBeatmapProcessor.cs

@@ -56,6 +56,7 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
                             rng.Next(); // osu!stable retrieved a random banana rotation
                             rng.Next(); // osu!stable retrieved a random banana colour
                         }
+
                         break;
                     case JuiceStream juiceStream:
                         foreach (var nested in juiceStream.NestedHitObjects)
@@ -67,6 +68,7 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
                                 rng.Next(); // osu!stable retrieved a random droplet rotation
                             hitObject.X = MathHelper.Clamp(hitObject.X, 0, 1);
                         }
+
                         break;
                 }
             }

osu.Game.Rulesets.Catch/CatchInputManager.cs

@@ -19,8 +19,10 @@ namespace osu.Game.Rulesets.Catch
     {
         [Description("Move left")]
         MoveLeft,
+
         [Description("Move right")]
         MoveRight,
+
         [Description("Engage dash")]
         Dash,
     }

osu.Game.Rulesets.Catch/Difficulty/CatchDifficultyCalculator.cs

@@ -68,14 +68,17 @@ namespace osu.Game.Rulesets.Catch.Difficulty
                     // We want to only consider fruits that contribute to the combo. Droplets are addressed as accuracy and spinners are not relevant for "skill" calculations.
                     case Fruit fruit:
                         yield return new CatchDifficultyHitObject(fruit, lastObject, clockRate, halfCatchWidth);
+
                         lastObject = hitObject;
                         break;
                     case JuiceStream _:
                         foreach (var nested in hitObject.NestedHitObjects.OfType<CatchHitObject>().Where(o => !(o is TinyDroplet)))
                         {
                             yield return new CatchDifficultyHitObject(nested, lastObject, clockRate, halfCatchWidth);
+
                             lastObject = nested;
                         }
+
                         break;
                 }
             }

osu.Game.Rulesets.Catch/MathUtils/FastRandom.cs

@@ -33,11 +33,11 @@ namespace osu.Game.Rulesets.Catch.MathUtils
         /// <returns>The random value.</returns>
         public uint NextUInt()
         {
-            uint t = _x ^ _x << 11;
+            uint t = _x ^ (_x << 11);
             _x = _y;
             _y = _z;
             _z = _w;
-            return _w = _w ^ _w >> 19 ^ t ^ t >> 8;
+            return _w = _w ^ (_w >> 19) ^ t ^ (t >> 8);
         }
 
         /// <summary>

osu.Game.Rulesets.Catch/Objects/Drawable/Pieces/Pulp.cs

@@ -23,6 +23,7 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable.Pieces
         }
 
         private Color4 accentColour;
+
         public Color4 AccentColour
         {
             get { return accentColour; }

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

@@ -40,29 +40,29 @@ namespace osu.Game.Rulesets.Mania.Tests
         protected override Ruleset CreateRuleset() => new ManiaRuleset();
     }
 
-     public class ManiaConvertMapping : ConvertMapping<ConvertValue>, IEquatable<ManiaConvertMapping>
+    public class ManiaConvertMapping : ConvertMapping<ConvertValue>, IEquatable<ManiaConvertMapping>
-     {
+    {
-         public uint RandomW;
+        public uint RandomW;
-         public uint RandomX;
+        public uint RandomX;
-         public uint RandomY;
+        public uint RandomY;
-         public uint RandomZ;
+        public uint RandomZ;
 
-         public ManiaConvertMapping()
+        public ManiaConvertMapping()
-         {
+        {
-         }
+        }
 
-         public ManiaConvertMapping(IBeatmapConverter converter)
+        public ManiaConvertMapping(IBeatmapConverter converter)
-         {
+        {
-             var maniaConverter = (ManiaBeatmapConverter)converter;
+            var maniaConverter = (ManiaBeatmapConverter)converter;
-             RandomW = maniaConverter.Random.W;
+            RandomW = maniaConverter.Random.W;
-             RandomX = maniaConverter.Random.X;
+            RandomX = maniaConverter.Random.X;
-             RandomY = maniaConverter.Random.Y;
+            RandomY = maniaConverter.Random.Y;
-             RandomZ = maniaConverter.Random.Z;
+            RandomZ = maniaConverter.Random.Z;
-         }
+        }
 
-         public bool Equals(ManiaConvertMapping other) => other != null && RandomW == other.RandomW && RandomX == other.RandomX && RandomY == other.RandomY && RandomZ == other.RandomZ;
+        public bool Equals(ManiaConvertMapping other) => other != null && RandomW == other.RandomW && RandomX == other.RandomX && RandomY == other.RandomY && RandomZ == other.RandomZ;
-         public override bool Equals(ConvertMapping<ConvertValue> other) => base.Equals(other) && Equals(other as ManiaConvertMapping);
+        public override bool Equals(ConvertMapping<ConvertValue> other) => base.Equals(other) && Equals(other as ManiaConvertMapping);
-     }
+    }
 
     public struct ConvertValue : IEquatable<ConvertValue>
     {

osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmapConverter.cs

@@ -78,6 +78,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
             if (maniaOriginal != null)
             {
                 yield return maniaOriginal;
+
                 yield break;
             }
 
@@ -92,6 +93,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
 
         private readonly List<double> prevNoteTimes = new List<double>(max_notes_for_density);
         private double density = int.MaxValue;
+
         private void computeDensity(double newNoteTime)
         {
             if (prevNoteTimes.Count == max_notes_for_density)
@@ -104,6 +106,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
         private double lastTime;
         private Vector2 lastPosition;
         private PatternType lastStair = PatternType.Stair;
+
         private void recordNote(double time, Vector2 position)
         {
             lastTime = time;

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

@@ -65,6 +65,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             if (originalPattern.HitObjects.Count() == 1)
             {
                 yield return originalPattern;
+
                 yield break;
             }
 
@@ -135,6 +136,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             {
                 if (convertType.HasFlag(PatternType.LowProbability))
                     return generateNRandomNotes(HitObject.StartTime, 0.78, 0.3, 0);
+
                 return generateNRandomNotes(HitObject.StartTime, 0.85, 0.36, 0.03);
             }
 
@@ -142,6 +144,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             {
                 if (convertType.HasFlag(PatternType.LowProbability))
                     return generateNRandomNotes(HitObject.StartTime, 0.43, 0.08, 0);
+
                 return generateNRandomNotes(HitObject.StartTime, 0.56, 0.18, 0);
             }
 
@@ -149,11 +152,13 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             {
                 if (convertType.HasFlag(PatternType.LowProbability))
                     return generateNRandomNotes(HitObject.StartTime, 0.3, 0, 0);
+
                 return generateNRandomNotes(HitObject.StartTime, 0.37, 0.08, 0);
             }
 
             if (convertType.HasFlag(PatternType.LowProbability))
                 return generateNRandomNotes(HitObject.StartTime, 0.17, 0, 0);
+
             return generateNRandomNotes(HitObject.StartTime, 0.27, 0, 0);
         }
 

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

@@ -116,10 +116,10 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                 }
 
                 if (convertType.HasFlag(PatternType.Cycle) && PreviousPattern.HitObjects.Count() == 1
-                                                          // If we convert to 7K + 1, let's not overload the special key
+                                                           // If we convert to 7K + 1, let's not overload the special key
-                                                          && (TotalColumns != 8 || lastColumn != 0)
+                                                           && (TotalColumns != 8 || lastColumn != 0)
-                                                          // Make sure the last column was not the centre column
+                                                           // Make sure the last column was not the centre column
-                                                          && (TotalColumns % 2 == 0 || lastColumn != TotalColumns / 2))
+                                                           && (TotalColumns % 2 == 0 || lastColumn != TotalColumns / 2))
                 {
                     // Generate a new pattern by cycling backwards (similar to Reverse but for only one hit object)
                     int column = RandomStart + TotalColumns - lastColumn - 1;
@@ -172,6 +172,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                         return pattern = generateRandomPatternWithMirrored(0.12, 0.38, 0.12);
                     if (ConversionDifficulty > 4)
                         return pattern = generateRandomPatternWithMirrored(0.12, 0.17, 0);
+
                     return pattern = generateRandomPatternWithMirrored(0.12, 0, 0);
                 }
 
@@ -179,6 +180,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                 {
                     if (convertType.HasFlag(PatternType.LowProbability))
                         return pattern = generateRandomPattern(0.78, 0.42, 0, 0);
+
                     return pattern = generateRandomPattern(1, 0.62, 0, 0);
                 }
 
@@ -186,6 +188,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                 {
                     if (convertType.HasFlag(PatternType.LowProbability))
                         return pattern = generateRandomPattern(0.35, 0.08, 0, 0);
+
                     return pattern = generateRandomPattern(0.52, 0.15, 0, 0);
                 }
 
@@ -193,6 +196,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                 {
                     if (convertType.HasFlag(PatternType.LowProbability))
                         return pattern = generateRandomPattern(0.18, 0, 0, 0);
+
                     return pattern = generateRandomPattern(0.45, 0, 0, 0);
                 }
 
@@ -250,6 +254,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                 }
                 else
                     last = GetRandomColumn();
+
                 return last;
             }
         }

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

@@ -87,6 +87,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                 return 4;
             if (val >= 1 - p3)
                 return 3;
+
             return val >= 1 - p2 ? 2 : 1;
         }
 

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

@@ -12,51 +12,63 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
     internal enum PatternType
     {
         None = 0,
+
         /// <summary>
         /// Keep the same as last row.
         /// </summary>
         ForceStack = 1 << 0,
+
         /// <summary>
         /// Keep different from last row.
         /// </summary>
         ForceNotStack = 1 << 1,
+
         /// <summary>
         /// Keep as single note at its original position.
         /// </summary>
         KeepSingle = 1 << 2,
+
         /// <summary>
         /// Use a lower random value.
         /// </summary>
         LowProbability = 1 << 3,
+
         /// <summary>
         /// Reserved.
         /// </summary>
         Alternate = 1 << 4,
+
         /// <summary>
         /// Ignore the repeat count.
         /// </summary>
         ForceSigSlider = 1 << 5,
+
         /// <summary>
         /// Convert slider to circle.
         /// </summary>
         ForceNotSlider = 1 << 6,
+
         /// <summary>
         /// Notes gathered together.
         /// </summary>
         Gathered = 1 << 7,
         Mirror = 1 << 8,
+
         /// <summary>
         /// Change 0 -> 6.
         /// </summary>
         Reverse = 1 << 9,
+
         /// <summary>
         /// 1 -> 5 -> 1 -> 5 like reverse.
         /// </summary>
         Cycle = 1 << 10,
+
         /// <summary>
         /// Next note will be at column + 1.
         /// </summary>
         Stair = 1 << 11,
+
         /// <summary>
         /// Next note will be at column - 1.
         /// </summary>

osu.Game.Rulesets.Mania/Difficulty/ManiaPerformanceCalculator.cs

@@ -114,8 +114,8 @@ namespace osu.Game.Rulesets.Mania.Difficulty
             // Lots of arbitrary values from testing.
             // Considering to use derivation from perfect accuracy in a probabilistic manner - assume normal distribution
             double accuracyValue = Math.Max(0.0, 0.2 - (Attributes.GreatHitWindow - 34) * 0.006667)
-                                       * strainValue
+                                   * strainValue
-                                       * Math.Pow(Math.Max(0.0, scaledScore - 960000) / 40000, 1.1);
+                                   * Math.Pow(Math.Max(0.0, scaledScore - 960000) / 40000, 1.1);
 
             // Bonus for many hitcircles - it's harder to keep good accuracy up for longer
             // accuracyValue *= Math.Min(1.15, Math.Pow(totalHits / 1500.0, 0.3));

osu.Game.Rulesets.Mania/ManiaInputManager.cs

@@ -19,6 +19,7 @@ namespace osu.Game.Rulesets.Mania
     {
         [Description("Special 1")]
         Special1 = 1,
+
         [Description("Special 2")]
         Special2,
 
@@ -26,38 +27,55 @@ namespace osu.Game.Rulesets.Mania
         // above at a later time, without breaking replays/configs.
         [Description("Key 1")]
         Key1 = 10,
+
         [Description("Key 2")]
         Key2,
+
         [Description("Key 3")]
         Key3,
+
         [Description("Key 4")]
         Key4,
+
         [Description("Key 5")]
         Key5,
+
         [Description("Key 6")]
         Key6,
+
         [Description("Key 7")]
         Key7,
+
         [Description("Key 8")]
         Key8,
+
         [Description("Key 9")]
         Key9,
+
         [Description("Key 10")]
         Key10,
+
         [Description("Key 11")]
         Key11,
+
         [Description("Key 12")]
         Key12,
+
         [Description("Key 13")]
         Key13,
+
         [Description("Key 14")]
         Key14,
+
         [Description("Key 15")]
         Key15,
+
         [Description("Key 16")]
         Key16,
+
         [Description("Key 17")]
         Key17,
+
         [Description("Key 18")]
         Key18,
     }

osu.Game.Rulesets.Mania/MathUtils/FastRandom.cs

@@ -37,11 +37,11 @@ namespace osu.Game.Rulesets.Mania.MathUtils
         /// <returns>The random value.</returns>
         public uint NextUInt()
         {
-            uint t = X ^ X << 11;
+            uint t = X ^ (X << 11);
             X = Y;
             Y = Z;
             Z = W;
-            return W = W ^ W >> 19 ^ t ^ t >> 8;
+            return W = W ^ (W >> 19) ^ t ^ (t >> 8);
         }
 
         /// <summary>

osu.Game.Rulesets.Mania/Objects/Drawables/Pieces/BodyPiece.cs

@@ -82,6 +82,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables.Pieces
             {
                 if (accentColour == value)
                     return;
+
                 accentColour = value;
 
                 updateAccentColour();

osu.Game.Rulesets.Mania/Objects/Drawables/Pieces/GlowPiece.cs

@@ -35,6 +35,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables.Pieces
         }
 
         private Color4 accentColour;
+
         public Color4 AccentColour
         {
             get { return accentColour; }
@@ -42,6 +43,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables.Pieces
             {
                 if (accentColour == value)
                     return;
+
                 accentColour = value;
 
                 updateGlow();

osu.Game.Rulesets.Mania/Objects/Drawables/Pieces/NotePiece.cs

@@ -56,6 +56,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables.Pieces
         }
 
         private Color4 accentColour;
+
         public Color4 AccentColour
         {
             get { return accentColour; }
@@ -63,6 +64,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables.Pieces
             {
                 if (accentColour == value)
                     return;
+
                 accentColour = value;
 
                 colouredBox.Colour = AccentColour.Lighten(0.9f);

osu.Game.Rulesets.Mania/Objects/HoldNote.cs

@@ -17,6 +17,7 @@ namespace osu.Game.Rulesets.Mania.Objects
         public double EndTime => StartTime + Duration;
 
         private double duration;
+
         public double Duration
         {
             get { return duration; }

osu.Game.Rulesets.Mania/Objects/ManiaHitWindows.cs

@@ -13,7 +13,7 @@ namespace osu.Game.Rulesets.Mania.Objects
         private static readonly IReadOnlyDictionary<HitResult, (double od0, double od5, double od10)> base_ranges = new Dictionary<HitResult, (double, double, double)>
         {
             { HitResult.Perfect, (44.8, 38.8, 27.8) },
-            { HitResult.Great, (128, 98, 68 ) },
+            { HitResult.Great, (128, 98, 68) },
             { HitResult.Good, (194, 164, 134) },
             { HitResult.Ok, (254, 224, 194) },
             { HitResult.Meh, (302, 272, 242) },

osu.Game.Rulesets.Mania/UI/Column.cs

@@ -97,6 +97,7 @@ namespace osu.Game.Rulesets.Mania.UI
         public override Axes RelativeSizeAxes => Axes.Y;
 
         private bool isSpecial;
+
         public bool IsSpecial
         {
             get { return isSpecial; }
@@ -104,6 +105,7 @@ namespace osu.Game.Rulesets.Mania.UI
             {
                 if (isSpecial == value)
                     return;
+
                 isSpecial = value;
 
                 Width = isSpecial ? special_column_width : column_width;
@@ -111,6 +113,7 @@ namespace osu.Game.Rulesets.Mania.UI
         }
 
         private Color4 accentColour;
+
         public Color4 AccentColour
         {
             get { return accentColour; }
@@ -118,6 +121,7 @@ namespace osu.Game.Rulesets.Mania.UI
             {
                 if (accentColour == value)
                     return;
+
                 accentColour = value;
 
                 background.AccentColour = value;

osu.Game.Rulesets.Mania/UI/Components/ColumnBackground.cs

@@ -70,6 +70,7 @@ namespace osu.Game.Rulesets.Mania.UI.Components
             {
                 if (accentColour == value)
                     return;
+
                 accentColour = value;
 
                 updateColours();

osu.Game.Rulesets.Mania/UI/Components/ColumnHitObjectArea.cs

@@ -73,6 +73,7 @@ namespace osu.Game.Rulesets.Mania.UI.Components
             {
                 if (accentColour == value)
                     return;
+
                 accentColour = value;
 
                 updateColours();

osu.Game.Rulesets.Mania/UI/Components/ColumnKeyArea.cs

@@ -87,6 +87,7 @@ namespace osu.Game.Rulesets.Mania.UI.Components
             {
                 if (accentColour == value)
                     return;
+
                 accentColour = value;
 
                 updateColours();

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

@@ -33,9 +33,11 @@ namespace osu.Game.Rulesets.Osu.Tests
                 case Slider slider:
                     foreach (var nested in slider.NestedHitObjects)
                         yield return createConvertValue(nested);
+
                     break;
                 default:
                     yield return createConvertValue(hitObject);
+
                     break;
             }
 

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

@@ -18,7 +18,7 @@ namespace osu.Game.Rulesets.Osu.Tests
     {
         private GameplayCursor cursor;
 
-        public override IReadOnlyList<Type> RequiredTypes => new [] { typeof(CursorTrail) };
+        public override IReadOnlyList<Type> RequiredTypes => new[] { typeof(CursorTrail) };
 
         public CursorContainer Cursor => cursor;
 

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

@@ -89,7 +89,8 @@ namespace osu.Game.Rulesets.Osu.Tests
         {
             private readonly bool auto;
 
-            public TestDrawableHitCircle(HitCircle h, bool auto) : base(h)
+            public TestDrawableHitCircle(HitCircle h, bool auto)
+                : base(h)
             {
                 this.auto = auto;
             }

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

@@ -301,6 +301,7 @@ namespace osu.Game.Rulesets.Osu.Tests
         }
 
         private float judgementOffsetDirection = 1;
+
         private void onNewResult(DrawableHitObject judgedObject, JudgementResult result)
         {
             var osuObject = judgedObject as DrawableOsuHitObject;

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

@@ -21,7 +21,7 @@ namespace osu.Game.Rulesets.Osu.Tests
     public class TestCaseSpinner : OsuTestCase
     {
         public override IReadOnlyList<Type> RequiredTypes => new[]
-{
+        {
             typeof(SpinnerDisc),
             typeof(DrawableSpinner),
             typeof(DrawableOsuHitObject)
@@ -67,7 +67,8 @@ namespace osu.Game.Rulesets.Osu.Tests
         {
             private bool auto;
 
-            public TestDrawableSpinner(Spinner s, bool auto) : base(s)
+            public TestDrawableSpinner(Spinner s, bool auto)
+                : base(s)
             {
                 this.auto = auto;
             }

osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs

@@ -97,7 +97,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
 
             // Longer maps are worth more
             double lengthBonus = 0.95f + 0.4f * Math.Min(1.0f, totalHits / 2000.0f) +
-                (totalHits > 2000 ? Math.Log10(totalHits / 2000.0f) * 0.5f : 0.0f);
+                                 (totalHits > 2000 ? Math.Log10(totalHits / 2000.0f) * 0.5f : 0.0f);
 
             aimValue *= lengthBonus;
 
@@ -113,7 +113,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
                 approachRateFactor += 0.3f * (Attributes.ApproachRate - 10.33f);
             else if (Attributes.ApproachRate < 8.0f)
             {
-                    approachRateFactor += 0.01f * (8.0f - Attributes.ApproachRate);
+                approachRateFactor += 0.01f * (8.0f - Attributes.ApproachRate);
             }
 
             aimValue *= approachRateFactor;
@@ -126,8 +126,10 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             {
                 // Apply object-based bonus for flashlight.
                 aimValue *= 1.0f + 0.35f * Math.Min(1.0f, totalHits / 200.0f) +
-                        (totalHits > 200 ? 0.3f * Math.Min(1.0f, (totalHits - 200) / 300.0f) +
+                            (totalHits > 200
-                        (totalHits > 500 ? (totalHits - 500) / 1200.0f : 0.0f) : 0.0f);
+                                ? 0.3f * Math.Min(1.0f, (totalHits - 200) / 300.0f) +
+                                  (totalHits > 500 ? (totalHits - 500) / 1200.0f : 0.0f)
+                                : 0.0f);
             }
 
             // Scale the aim value with accuracy _slightly_
@@ -144,7 +146,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
 
             // Longer maps are worth more
             speedValue *= 0.95f + 0.4f * Math.Min(1.0f, totalHits / 2000.0f) +
-                (totalHits > 2000 ? Math.Log10(totalHits / 2000.0f) * 0.5f : 0.0f);
+                          (totalHits > 2000 ? Math.Log10(totalHits / 2000.0f) * 0.5f : 0.0f);
 
             // Penalize misses exponentially. This mainly fixes tag4 maps and the likes until a per-hitobject solution is available
             speedValue *= Math.Pow(0.97f, countMiss);

osu.Game.Rulesets.Osu/Difficulty/Preprocessing/OsuDifficultyHitObject.cs

@@ -92,6 +92,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
         {
             if (slider.LazyEndPosition != null)
                 return;
+
             slider.LazyEndPosition = slider.StackedPosition;
 
             float approxFollowCircleRadius = (float)(slider.Radius * 3);

osu.Game.Rulesets.Osu/Judgements/ComboResult.cs

@@ -9,8 +9,10 @@ namespace osu.Game.Rulesets.Osu.Judgements
     {
         [Description(@"")]
         None,
+
         [Description(@"Good")]
         Good,
+
         [Description(@"Amazing")]
         Perfect
     }

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

@@ -28,7 +28,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         {
             foreach (var drawable in drawables)
             {
-                var hitObject = (OsuHitObject) drawable.HitObject;
+                var hitObject = (OsuHitObject)drawable.HitObject;
 
                 float appearDistance = (float)(hitObject.TimePreempt - hitObject.TimeFadeIn) / 2;
 
@@ -46,7 +46,7 @@ namespace osu.Game.Rulesets.Osu.Mods
                         .MoveTo(originalPosition, moveDuration, Easing.InOutSine);
                 }
 
-                theta += (float) hitObject.TimeFadeIn / 1000;
+                theta += (float)hitObject.TimeFadeIn / 1000;
             }
         }
     }

osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderTick.cs

@@ -20,7 +20,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
         public override bool DisplayResult => false;
 
-        public DrawableSliderTick(SliderTick sliderTick) : base(sliderTick)
+        public DrawableSliderTick(SliderTick sliderTick)
+            : base(sliderTick)
         {
             Size = new Vector2(16) * sliderTick.Scale;
             Origin = Anchor.Centre;

osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs

@@ -42,7 +42,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         private Color4 normalColour;
         private Color4 completeColour;
 
-        public DrawableSpinner(Spinner s) : base(s)
+        public DrawableSpinner(Spinner s)
+            : base(s)
         {
             Origin = Anchor.Centre;
             Position = s.Position;

osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SliderBody.cs

@@ -40,6 +40,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
             {
                 if (path.AccentColour == value)
                     return;
+
                 path.AccentColour = value;
 
                 container.ForceRedraw();
@@ -56,6 +57,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
             {
                 if (path.BorderColour == value)
                     return;
+
                 path.BorderColour = value;
 
                 container.ForceRedraw();
@@ -105,6 +107,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
                 {
                     if (borderColour == value)
                         return;
+
                     borderColour = value;
 
                     InvalidateTexture();
@@ -120,6 +123,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
                 {
                     if (accentColour == value)
                         return;
+
                     accentColour = value;
 
                     InvalidateTexture();

osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SpinnerDisc.cs

@@ -43,12 +43,14 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => true;
 
         private bool tracking;
+
         public bool Tracking
         {
             get { return tracking; }
             set
             {
                 if (value == tracking) return;
+
                 tracking = value;
 
                 background.FadeTo(tracking ? tracking_alpha : idle_alpha, 100);
@@ -56,12 +58,14 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
         }
 
         private bool complete;
+
         public bool Complete
         {
             get { return complete; }
             set
             {
                 if (value == complete) return;
+
                 complete = value;
 
                 updateCompleteTick();

osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SpinnerSpmCounter.cs

@@ -45,6 +45,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
             private set
             {
                 if (value == spm) return;
+
                 spm = value;
                 spmText.Text = Math.Truncate(value).ToString(@"#0");
             }

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

@@ -262,6 +262,7 @@ namespace osu.Game.Rulesets.Osu.Objects
         {
             if (nodeIndex < NodeSamples.Count)
                 return NodeSamples[nodeIndex];
+
             return Samples;
         }
 

osu.Game.Rulesets.Osu/OsuInputManager.cs

@@ -38,6 +38,7 @@ namespace osu.Game.Rulesets.Osu
             protected override bool Handle(UIEvent e)
             {
                 if (!AllowUserPresses) return false;
+
                 return base.Handle(e);
             }
         }

osu.Game.Rulesets.Osu/OsuRuleset.cs

@@ -121,7 +121,8 @@ namespace osu.Game.Rulesets.Osu
                         new OsuModAutopilot(),
                     };
                 case ModType.Fun:
-                    return new Mod[] {
+                    return new Mod[]
+                    {
                         new OsuModTransform(),
                         new OsuModWiggle(),
                         new OsuModGrow()

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

@@ -209,7 +209,7 @@ namespace osu.Game.Rulesets.Osu.Replays
             // Only "snap" to hitcircles if they are far enough apart. As the time between hitcircles gets shorter the snapping threshold goes up.
             if (timeDifference > 0 && // Sanity checks
                 ((lastPosition - targetPos).Length > h.Radius * (1.5 + 100.0 / timeDifference) || // Either the distance is big enough
-                timeDifference >= 266)) // ... or the beats are slow enough to tap anyway.
+                 timeDifference >= 266)) // ... or the beats are slow enough to tap anyway.
             {
                 // Perform eased movement
                 for (double time = lastFrame.Time + FrameDelay; time < h.StartTime; time += FrameDelay)

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

@@ -20,6 +20,7 @@ namespace osu.Game.Rulesets.Osu.Replays
         /// Constants (for spinners).
         /// </summary>
         protected static readonly Vector2 SPINNER_CENTRE = OsuPlayfield.BASE_SIZE / 2;
+
         protected const float SPIN_RADIUS = 50;
 
         /// <summary>
@@ -46,6 +47,7 @@ namespace osu.Game.Rulesets.Osu.Replays
         #endregion
 
         #region Utilities
+
         protected double ApplyModsToTime(double v) => v;
         protected double ApplyModsToRate(double v) => v;
 

osu.Game.Rulesets.Osu/UI/Cursor/CursorTrail.cs

@@ -255,10 +255,13 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
         {
             [VertexMember(2, VertexAttribPointerType.Float)]
             public Vector2 Position;
+
             [VertexMember(4, VertexAttribPointerType.Float)]
             public Color4 Colour;
+
             [VertexMember(2, VertexAttribPointerType.Float)]
             public Vector2 TexturePosition;
+
             [VertexMember(1, VertexAttribPointerType.Float)]
             public float Time;
 

osu.Game.Rulesets.Osu/UI/Cursor/GameplayCursor.cs

@@ -213,6 +213,7 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
             public void Expand()
             {
                 if (!cursorExpand) return;
+
                 expandTarget.ScaleTo(released_scale).ScaleTo(pressed_scale, 100, Easing.OutQuad);
             }
 

osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableSwell.cs

@@ -229,6 +229,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
             // Ensure alternating centre and rim hits
             if (lastWasCentre == isCentre)
                 return false;
+
             lastWasCentre = isCentre;
 
             UpdateResult(true);

osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableTaikoHitObject.cs

@@ -49,6 +49,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
         protected void ProxyContent()
         {
             if (isProxied) return;
+
             isProxied = true;
 
             nonProxiedContent.Remove(Content);
@@ -62,6 +63,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
         protected void UnproxyContent()
         {
             if (!isProxied) return;
+
             isProxied = false;
 
             proxiedContent.Remove(Content);

osu.Game.Rulesets.Taiko/Objects/Drawables/Pieces/TaikoPiece.cs

@@ -11,6 +11,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables.Pieces
     public class TaikoPiece : BeatSyncedContainer, IHasAccentColour
     {
         private Color4 accentColour;
+
         /// <summary>
         /// The colour of the inner circle and outer glows.
         /// </summary>
@@ -21,16 +22,14 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables.Pieces
         }
 
         private bool kiaiMode;
+
         /// <summary>
         /// Whether Kiai mode effects are enabled for this circle piece.
         /// </summary>
         public virtual bool KiaiMode
         {
             get { return kiaiMode; }
-            set
+            set { kiaiMode = value; }
-            {
-                kiaiMode = value;
-            }
         }
 
         public TaikoPiece()

osu.Game.Rulesets.Taiko/Objects/Drawables/Pieces/TickPiece.cs

@@ -23,6 +23,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables.Pieces
         private const float tick_size = 0.35f;
 
         private bool filled;
+
         public bool Filled
         {
             get { return filled; }

osu.Game.Rulesets.Taiko/Objects/Swell.cs

@@ -19,7 +19,10 @@ namespace osu.Game.Rulesets.Taiko.Objects
         /// </summary>
         public int RequiredHits = 10;
 
-        public override bool IsStrong { set => throw new NotSupportedException($"{nameof(Swell)} cannot be a strong hitobject."); }
+        public override bool IsStrong
+        {
+            set => throw new NotSupportedException($"{nameof(Swell)} cannot be a strong hitobject.");
+        }
 
         protected override void CreateNestedHitObjects()
         {

osu.Game.Rulesets.Taiko/TaikoInputManager.cs

@@ -19,10 +19,13 @@ namespace osu.Game.Rulesets.Taiko
     {
         [Description("Left (rim)")]
         LeftRim,
+
         [Description("Left (centre)")]
         LeftCentre,
+
         [Description("Right (centre)")]
         RightCentre,
+
         [Description("Right (rim)")]
         RightRim
     }

osu.Game.Tests/Visual/TestCaseBeatSyncedContainer.cs

@@ -141,6 +141,7 @@ namespace osu.Game.Tests.Visual
             }
 
             private SortedList<TimingControlPoint> timingPoints => Beatmap.Value.Beatmap.ControlPointInfo.TimingPoints;
+
             private TimingControlPoint getNextTimingPoint(TimingControlPoint current)
             {
                 if (timingPoints[timingPoints.Count - 1] == current)

osu.Game.Tests/Visual/TestCaseBeatmapCarousel.cs

@@ -150,6 +150,7 @@ namespace osu.Game.Tests.Visual
             var currentlySelected = carousel.Items.Find(s => s.Item is CarouselBeatmap && s.Item.State.Value == CarouselItemState.Selected);
             if (currentlySelected == null)
                 return true;
+
             return currentlySelected.Item.Visible;
         }
 
@@ -162,11 +163,11 @@ namespace osu.Game.Tests.Visual
         private void checkNonmatchingFilter()
         {
             AddStep("Toggle non-matching filter", () =>
-            {
+                {
-                carousel.Filter(new FilterCriteria { SearchText = "Dingo" }, false);
+                    carousel.Filter(new FilterCriteria { SearchText = "Dingo" }, false);
-                carousel.Filter(new FilterCriteria(), false);
+                    carousel.Filter(new FilterCriteria(), false);
-                eagerSelectedIDs.Add(carousel.SelectedBeatmapSet.ID);
+                    eagerSelectedIDs.Add(carousel.SelectedBeatmapSet.ID);
-            }
+                }
             );
         }
 
@@ -522,6 +523,7 @@ namespace osu.Game.Tests.Visual
                     }
                 });
             }
+
             return toReturn;
         }
 

osu.Game.Tests/Visual/TestCaseChatLink.cs

@@ -56,7 +56,7 @@ namespace osu.Game.Tests.Visual
 
             var chatManager = new ChannelManager();
             BindableList<Channel> availableChannels = (BindableList<Channel>)chatManager.AvailableChannels;
-            availableChannels.Add(new Channel { Name = "#english"});
+            availableChannels.Add(new Channel { Name = "#english" });
             availableChannels.Add(new Channel { Name = "#japanese" });
             Dependencies.Cache(chatManager);
 

osu.Game.Tests/Visual/TestCaseContextMenu.cs

@@ -61,10 +61,10 @@ namespace osu.Game.Tests.Visual
 
             // Move box along a square trajectory
             container.Loop(c => c
-                .MoveTo(new Vector2(0, 100), duration).Then()
+                                .MoveTo(new Vector2(0, 100), duration).Then()
-                .MoveTo(new Vector2(100, 100), duration).Then()
+                                .MoveTo(new Vector2(100, 100), duration).Then()
-                .MoveTo(new Vector2(100, 0), duration).Then()
+                                .MoveTo(new Vector2(100, 0), duration).Then()
-                .MoveTo(Vector2.Zero, duration)
+                                .MoveTo(Vector2.Zero, duration)
             );
         }
 

osu.Game.Tests/Visual/TestCaseEditorSeekSnapping.cs

@@ -33,7 +33,7 @@ namespace osu.Game.Tests.Visual
                 {
                     TimingPoints =
                     {
-                        new TimingControlPoint { Time = 0, BeatLength = 200},
+                        new TimingControlPoint { Time = 0, BeatLength = 200 },
                         new TimingControlPoint { Time = 100, BeatLength = 400 },
                         new TimingControlPoint { Time = 175, BeatLength = 800 },
                         new TimingControlPoint { Time = 350, BeatLength = 200 },

osu.Game.Tests/Visual/TestCaseGameplayMenuOverlay.cs

@@ -265,6 +265,7 @@ namespace osu.Game.Tests.Visual
                     pauseOverlay.OnRetry = lastAction;
                     lastAction = null;
                 }
+
                 return triggered;
             });
             AddAssert("Overlay is closed", () => pauseOverlay.State == Visibility.Hidden);

osu.Game.Tests/Visual/TestCaseLeaderboard.cs

@@ -20,7 +20,8 @@ namespace osu.Game.Tests.Visual
     [Description("PlaySongSelect leaderboard")]
     public class TestCaseLeaderboard : OsuTestCase
     {
-        public override IReadOnlyList<Type> RequiredTypes => new[] {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
             typeof(Placeholder),
             typeof(MessagePlaceholder),
             typeof(RetrievalFailurePlaceholder),

osu.Game.Tests/Visual/TestCasePlaybackControl.cs

@@ -26,7 +26,7 @@ namespace osu.Game.Tests.Visual
             {
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
-                Size = new Vector2(200,100)
+                Size = new Vector2(200, 100)
             };
 
             Beatmap.Value = new TestWorkingBeatmap(new Beatmap(), Clock);

osu.Game.Tests/Visual/TestCaseScreenBreadcrumbControl.cs

@@ -84,7 +84,7 @@ namespace osu.Game.Tests.Visual
             public TestScreen PushNext()
             {
                 TestScreen screen = CreateNextScreen();
-               this.Push(screen);
+                this.Push(screen);
 
                 return screen;
             }

osu.Game.Tests/Visual/TestCaseStoryboard.cs

@@ -50,7 +50,10 @@ namespace osu.Game.Tests.Visual
             });
 
             AddStep("Restart", restart);
-            AddToggleStep("Passing", passing => { if (storyboard != null) storyboard.Passing = passing; });
+            AddToggleStep("Passing", passing =>
+            {
+                if (storyboard != null) storyboard.Passing = passing;
+            });
         }
 
         [BackgroundDependencyLoader]

osu.Game/Audio/SampleInfo.cs

@@ -50,12 +50,14 @@ namespace osu.Game.Audio
                 {
                     if (!string.IsNullOrEmpty(Suffix))
                         yield return $"{Namespace}/{Bank}-{Name}{Suffix}";
+
                     yield return $"{Namespace}/{Bank}-{Name}";
                 }
 
                 // check non-namespace as a fallback even when we have a namespace
                 if (!string.IsNullOrEmpty(Suffix))
                     yield return $"{Bank}-{Name}{Suffix}";
+
                 yield return $"{Bank}-{Name}";
             }
         }

osu.Game/Beatmaps/BeatmapConverter.cs

@@ -16,6 +16,7 @@ namespace osu.Game.Beatmaps
         where T : HitObject
     {
         private event Action<HitObject, IEnumerable<HitObject>> ObjectConverted;
+
         event Action<HitObject, IEnumerable<HitObject>> IBeatmapConverter.ObjectConverted
         {
             add => ObjectConverted += value;

osu.Game/Beatmaps/BeatmapDifficulty.cs

@@ -48,6 +48,7 @@ namespace osu.Game.Beatmaps
                 return mid + (max - mid) * (difficulty - 5) / 5;
             if (difficulty < 5)
                 return mid - (mid - min) * (5 - difficulty) / 5;
+
             return mid;
         }
 

osu.Game/Beatmaps/BeatmapMetadata.cs

@@ -48,6 +48,7 @@ namespace osu.Game.Beatmaps
 
         [JsonProperty(@"tags")]
         public string Tags { get; set; }
+
         public int PreviewTime { get; set; }
         public string AudioFile { get; set; }
         public string BackgroundFile { get; set; }
@@ -72,15 +73,15 @@ namespace osu.Game.Beatmaps
                 return false;
 
             return Title == other.Title
-                && TitleUnicode == other.TitleUnicode
+                   && TitleUnicode == other.TitleUnicode
-                && Artist == other.Artist
+                   && Artist == other.Artist
-                && ArtistUnicode == other.ArtistUnicode
+                   && ArtistUnicode == other.ArtistUnicode
-                && AuthorString == other.AuthorString
+                   && AuthorString == other.AuthorString
-                && Source == other.Source
+                   && Source == other.Source
-                && Tags == other.Tags
+                   && Tags == other.Tags
-                && PreviewTime == other.PreviewTime
+                   && PreviewTime == other.PreviewTime
-                && AudioFile == other.AudioFile
+                   && AudioFile == other.AudioFile
-                && BackgroundFile == other.BackgroundFile;
+                   && BackgroundFile == other.BackgroundFile;
         }
     }
 }

osu.Game/Beatmaps/BeatmapStore.cs

@@ -34,6 +34,7 @@ namespace osu.Game.Beatmaps
                 Refresh(ref beatmap, Beatmaps);
 
                 if (beatmap.Hidden) return false;
+
                 beatmap.Hidden = true;
             }
 
@@ -53,6 +54,7 @@ namespace osu.Game.Beatmaps
                 Refresh(ref beatmap, Beatmaps);
 
                 if (!beatmap.Hidden) return false;
+
                 beatmap.Hidden = false;
             }
 

osu.Game/Beatmaps/Drawables/BeatmapBackgroundSprite.cs

@@ -13,8 +13,8 @@ namespace osu.Game.Beatmaps.Drawables
 
         public BeatmapBackgroundSprite(WorkingBeatmap working)
         {
-             if (working == null)
+            if (working == null)
-                 throw new ArgumentNullException(nameof(working));
+                throw new ArgumentNullException(nameof(working));
 
             this.working = working;
         }

osu.Game/Beatmaps/Drawables/BeatmapSetOnlineStatusPill.cs

@@ -23,6 +23,7 @@ namespace osu.Game.Beatmaps.Drawables
             {
                 if (status == value)
                     return;
+
                 status = value;
 
                 Alpha = value == BeatmapSetOnlineStatus.None ? 0 : 1;

osu.Game/Beatmaps/Drawables/DifficultyColouredContainer.cs

@@ -53,6 +53,7 @@ namespace osu.Game.Beatmaps.Drawables
             if (rating < 3.75) return DifficultyRating.Hard;
             if (rating < 5.25) return DifficultyRating.Insane;
             if (rating < 6.75) return DifficultyRating.Expert;
+
             return DifficultyRating.ExpertPlus;
         }
 

osu.Game/Beatmaps/Drawables/UpdateableBeatmapBackgroundSprite.cs

@@ -25,7 +25,8 @@ namespace osu.Game.Beatmaps.Drawables
 
         protected override Drawable CreateDrawable(BeatmapInfo model)
         {
-            return new DelayedLoadUnloadWrapper(() => {
+            return new DelayedLoadUnloadWrapper(() =>
+            {
                 Drawable drawable;
 
                 var localBeatmap = beatmaps.GetWorkingBeatmap(model);

osu.Game/Beatmaps/Drawables/UpdateableBeatmapSetCover.cs

@@ -13,12 +13,14 @@ namespace osu.Game.Beatmaps.Drawables
         private Drawable displayedCover;
 
         private BeatmapSetInfo beatmapSet;
+
         public BeatmapSetInfo BeatmapSet
         {
             get { return beatmapSet; }
             set
             {
                 if (value == beatmapSet) return;
+
                 beatmapSet = value;
 
                 if (IsLoaded)
@@ -27,12 +29,14 @@ namespace osu.Game.Beatmaps.Drawables
         }
 
         private BeatmapSetCoverType coverType = BeatmapSetCoverType.Cover;
+
         public BeatmapSetCoverType CoverType
         {
             get { return coverType; }
             set
             {
                 if (value == coverType) return;
+
                 coverType = value;
 
                 if (IsLoaded)

osu.Game/Beatmaps/Formats/LegacyDecoder.cs

@@ -72,6 +72,7 @@ namespace osu.Game.Beatmaps.Formats
             var index = line.AsSpan().IndexOf("//".AsSpan());
             if (index > 0)
                 return line.Substring(0, index);
+
             return line;
         }
 
@@ -115,6 +116,7 @@ namespace osu.Game.Beatmaps.Formats
             else
             {
                 if (!(output is IHasCustomColours tHasCustomColours)) return;
+
                 tHasCustomColours.CustomColours[pair.Key] = colour;
             }
         }

osu.Game/Configuration/RandomSelectAlgorithm.cs

@@ -5,10 +5,11 @@ using System.ComponentModel;
 
 namespace osu.Game.Configuration
 {
-   public enum RandomSelectAlgorithm
+    public enum RandomSelectAlgorithm
     {
         [Description("Never repeat")]
         RandomPermutation,
+
         [Description("Random")]
         Random
     }

osu.Game/Configuration/RankingType.cs

@@ -8,8 +8,10 @@ namespace osu.Game.Configuration
     public enum RankingType
     {
         Local,
+
         [Description("Global")]
         Top,
+
         [Description("Selected Mods")]
         SelectedMod,
         Friends,

osu.Game/Configuration/ScalingMode.cs

@@ -9,6 +9,7 @@ namespace osu.Game.Configuration
     {
         Off,
         Everything,
+
         [Description("Excluding overlays")]
         ExcludeOverlays,
         Gameplay,

osu.Game/Configuration/ScreenshotFormat.cs

@@ -9,6 +9,7 @@ namespace osu.Game.Configuration
     {
         [Description("JPG (web-friendly)")]
         Jpg = 1,
+
         [Description("PNG (lossless)")]
         Png = 2
     }

osu.Game/Configuration/ScrollVisualisationMethod.cs

@@ -9,8 +9,10 @@ namespace osu.Game.Configuration
     {
         [Description("Sequential")]
         Sequential,
+
         [Description("Overlapping")]
         Overlapping,
+
         [Description("Constant")]
         Constant
     }

osu.Game/Database/ArchiveModelManager.cs

@@ -539,6 +539,7 @@ namespace osu.Game.Database
                 return new LegacyDirectoryArchiveReader(path);
             if (File.Exists(path))
                 return new LegacyFileArchiveReader(path);
+
             throw new InvalidFormatException($"{path} is not a valid archive");
         }
     }

osu.Game/Database/DatabaseWriteUsage.cs

@@ -31,6 +31,7 @@ namespace osu.Game.Database
         protected void Dispose(bool disposing)
         {
             if (isDisposed) return;
+
             isDisposed = true;
 
             try

osu.Game/Database/MutableDatabaseBackedStore.cs

@@ -71,6 +71,7 @@ namespace osu.Game.Database
                 Refresh(ref item);
 
                 if (item.DeletePending) return false;
+
                 item.DeletePending = true;
             }
 
@@ -89,6 +90,7 @@ namespace osu.Game.Database
                 Refresh(ref item, ConsumableItems);
 
                 if (!item.DeletePending) return false;
+
                 item.DeletePending = false;
             }
 

osu.Game/Graphics/Backgrounds/Triangles.cs

@@ -110,10 +110,10 @@ namespace osu.Game.Graphics.Backgrounds
             if (CreateNewTriangles)
                 addTriangles(false);
 
-            float adjustedAlpha = HideAlphaDiscrepancies ?
+            float adjustedAlpha = HideAlphaDiscrepancies
                 // Cubically scale alpha to make it drop off more sharply.
-                (float)Math.Pow(DrawColourInfo.Colour.AverageColour.Linear.A, 3) :
+                ? (float)Math.Pow(DrawColourInfo.Colour.AverageColour.Linear.A, 3)
-                1;
+                : 1;
 
             float elapsedSeconds = (float)Time.Elapsed / 1000;
             // Since position is relative, the velocity needs to scale inversely with DrawHeight.
@@ -181,6 +181,7 @@ namespace osu.Game.Graphics.Backgrounds
         protected override DrawNode CreateDrawNode() => new TrianglesDrawNode();
 
         private readonly TrianglesDrawNodeSharedData sharedData = new TrianglesDrawNodeSharedData();
+
         protected override void ApplyDrawNode(DrawNode node)
         {
             base.ApplyDrawNode(node);

osu.Game/Graphics/Containers/OsuFocusedOverlayContainer.cs

@@ -96,6 +96,7 @@ namespace osu.Game.Graphics.Containers
                     }
                     else
                         State = Visibility.Hidden;
+
                     break;
                 case Visibility.Hidden:
                     if (PlaySamplesOnStateChange) samplePopOut?.Play();

osu.Game/Graphics/Containers/OsuTextFlowContainer.cs

@@ -12,7 +12,8 @@ namespace osu.Game.Graphics.Containers
 {
     public class OsuTextFlowContainer : TextFlowContainer
     {
-        public OsuTextFlowContainer(Action<SpriteText> defaultCreationParameters = null) : base(defaultCreationParameters)
+        public OsuTextFlowContainer(Action<SpriteText> defaultCreationParameters = null)
+            : base(defaultCreationParameters)
         {
         }
 

osu.Game/Graphics/Containers/SectionsContainer.cs

@@ -110,6 +110,7 @@ namespace osu.Game.Graphics.Containers
 
         private float headerHeight, footerHeight;
         private readonly MarginPadding originalSectionsMargin;
+
         private void updateSectionsMargin()
         {
             if (!Children.Any()) return;
@@ -142,6 +143,7 @@ namespace osu.Game.Graphics.Containers
         public void ScrollToTop() => scrollContainer.ScrollTo(0);
 
         private float lastKnownScroll;
+
         protected override void UpdateAfterChildren()
         {
             base.UpdateAfterChildren();

osu.Game/Graphics/Cursor/MenuCursor.cs

@@ -85,6 +85,7 @@ namespace osu.Game.Graphics.Cursor
                 dragRotationState = DragRotationState.DragStarted;
                 positionMouseDown = e.MousePosition;
             }
+
             return base.OnMouseDown(e);
         }
 
@@ -102,6 +103,7 @@ namespace osu.Game.Graphics.Cursor
                     activeCursor.RotateTo(0, 600 * (1 + Math.Abs(activeCursor.Rotation / 720)), Easing.OutElasticHalf);
                 dragRotationState = DragRotationState.NotDragging;
             }
+
             return base.OnMouseUp(e);
         }
 

osu.Game/Graphics/Cursor/MenuCursorContainer.cs

@@ -43,6 +43,7 @@ namespace osu.Game.Graphics.Cursor
         }
 
         private IProvideCursor currentTarget;
+
         protected override void Update()
         {
             base.Update();

osu.Game/Graphics/Cursor/OsuTooltipContainer.cs

@@ -17,7 +17,8 @@ namespace osu.Game.Graphics.Cursor
     {
         protected override ITooltip CreateTooltip() => new OsuTooltip();
 
-        public OsuTooltipContainer(CursorContainer cursor) : base(cursor)
+        public OsuTooltipContainer(CursorContainer cursor)
+            : base(cursor)
         {
         }
 

osu.Game/Graphics/DrawableDate.cs

@@ -21,6 +21,7 @@ namespace osu.Game.Graphics
             {
                 if (date == value)
                     return;
+
                 date = value.ToLocalTime();
 
                 if (LoadState >= LoadState.Ready)

osu.Game/Graphics/SpriteIcon.cs

@@ -65,6 +65,7 @@ namespace osu.Game.Graphics
         }
 
         private FontAwesome loadedIcon;
+
         private void updateTexture()
         {
             var loadableIcon = icon;
@@ -104,6 +105,7 @@ namespace osu.Game.Graphics
         }
 
         private bool shadow;
+
         public bool Shadow
         {
             get { return shadow; }
@@ -119,10 +121,7 @@ namespace osu.Game.Graphics
 
         public FontAwesome Icon
         {
-            get
+            get { return icon; }
-            {
-                return icon;
-            }
 
             set
             {

osu.Game/Graphics/UserInterface/Bar.cs

@@ -26,10 +26,7 @@ namespace osu.Game.Graphics.UserInterface
         /// </summary>
         public float Length
         {
-            get
+            get { return length; }
-            {
-                return length;
-            }
             set
             {
                 length = MathHelper.Clamp(value, 0, 1);
@@ -39,35 +36,21 @@ namespace osu.Game.Graphics.UserInterface
 
         public Color4 BackgroundColour
         {
-            get
+            get => background.Colour;
-            {
+            set => background.Colour = value;
-                return background.Colour;
-            }
-            set
-            {
-                background.Colour = value;
-            }
         }
 
         public Color4 AccentColour
         {
-            get
+            get => bar.Colour;
-            {
+            set => bar.Colour = value;
-                return bar.Colour;
-            }
-            set
-            {
-                bar.Colour = value;
-            }
         }
 
         private BarDirection direction = BarDirection.LeftToRight;
+
         public BarDirection Direction
         {
-            get
+            get { return direction; }
-            {
-                return direction;
-            }
             set
             {
                 direction = value;

osu.Game/Graphics/UserInterface/BarGraph.cs

@@ -17,6 +17,7 @@ namespace osu.Game.Graphics.UserInterface
         public float? MaxValue { get; set; }
 
         private BarDirection direction = BarDirection.BottomToTop;
+
         public new BarDirection Direction
         {
             get
@@ -69,6 +70,7 @@ namespace osu.Game.Graphics.UserInterface
                         });
                     }
                 }
+
                 //I'm using ToList() here because Where() returns an Enumerable which can change it's elements afterwards
                 RemoveRange(Children.Where((bar, index) => index >= value.Count()).ToList());
             }

osu.Game/Graphics/UserInterface/BreadcrumbControl.cs

@@ -61,6 +61,7 @@ namespace osu.Game.Graphics.UserInterface
                 set
                 {
                     if (value == state) return;
+
                     state = value;
 
                     const float transition_duration = 500;
@@ -80,7 +81,8 @@ namespace osu.Game.Graphics.UserInterface
                 }
             }
 
-            public BreadcrumbTabItem(T value) : base(value)
+            public BreadcrumbTabItem(T value)
+                : base(value)
             {
                 Text.Font = Text.Font.With(size: 18);
                 Text.Margin = new MarginPadding { Vertical = 8 };

osu.Game/Graphics/UserInterface/DialogButton.cs

@@ -154,12 +154,10 @@ namespace osu.Game.Graphics.UserInterface
         }
 
         private Color4 buttonColour;
+
         public Color4 ButtonColour
         {
-            get
+            get { return buttonColour; }
-            {
-                return buttonColour;
-            }
             set
             {
                 buttonColour = value;
@@ -169,12 +167,10 @@ namespace osu.Game.Graphics.UserInterface
         }
 
         private Color4 backgroundColour = OsuColour.Gray(34);
+
         public Color4 BackgroundColour
         {
-            get
+            get { return backgroundColour; }
-            {
-                return backgroundColour;
-            }
             set
             {
                 backgroundColour = value;
@@ -183,12 +179,10 @@ namespace osu.Game.Graphics.UserInterface
         }
 
         private string text;
+
         public string Text
         {
-            get
+            get { return text; }
-            {
-                return text;
-            }
             set
             {
                 text = value;

osu.Game/Graphics/UserInterface/ExternalLinkButton.cs

@@ -51,7 +51,7 @@ namespace osu.Game.Graphics.UserInterface
 
         protected override bool OnClick(ClickEvent e)
         {
-            if(Link != null)
+            if (Link != null)
                 host.OpenUrlExternally(Link);
             return true;
         }

osu.Game/Graphics/UserInterface/HoverClickSounds.cs

@@ -17,7 +17,8 @@ namespace osu.Game.Graphics.UserInterface
     {
         private SampleChannel sampleClick;
 
-        public HoverClickSounds(HoverSampleSet sampleSet = HoverSampleSet.Normal) : base(sampleSet)
+        public HoverClickSounds(HoverSampleSet sampleSet = HoverSampleSet.Normal)
+            : base(sampleSet)
         {
         }
 

osu.Game/Graphics/UserInterface/HoverSounds.cs

@@ -45,8 +45,10 @@ namespace osu.Game.Graphics.UserInterface
     {
         [Description("")]
         Loud,
+
         [Description("-soft")]
         Normal,
+
         [Description("-softer")]
         Soft
     }

osu.Game/Graphics/UserInterface/LineGraph.cs

@@ -112,6 +112,7 @@ namespace osu.Game.Graphics.UserInterface
         protected float GetYPosition(float value)
         {
             if (ActualMaxValue == ActualMinValue) return 0;
+
             return (ActualMaxValue - value) / (ActualMaxValue - ActualMinValue);
         }
     }

osu.Game/Graphics/UserInterface/Nub.cs

@@ -72,6 +72,7 @@ namespace osu.Game.Graphics.UserInterface
         }
 
         private bool glowing;
+
         public bool Glowing
         {
             get { return glowing; }
@@ -94,10 +95,7 @@ namespace osu.Game.Graphics.UserInterface
 
         public bool Expanded
         {
-            set
+            set { this.ResizeTo(new Vector2(value ? EXPANDED_SIZE : COLLAPSED_SIZE, 12), 500, Easing.OutQuint); }
-            {
-                this.ResizeTo(new Vector2(value ? EXPANDED_SIZE : COLLAPSED_SIZE, 12), 500, Easing.OutQuint);
-            }
         }
 
         private readonly Bindable<bool> current = new Bindable<bool>();
@@ -116,6 +114,7 @@ namespace osu.Game.Graphics.UserInterface
         }
 
         private Color4 accentColour;
+
         public Color4 AccentColour
         {
             get { return accentColour; }
@@ -128,6 +127,7 @@ namespace osu.Game.Graphics.UserInterface
         }
 
         private Color4 glowingAccentColour;
+
         public Color4 GlowingAccentColour
         {
             get { return glowingAccentColour; }
@@ -140,6 +140,7 @@ namespace osu.Game.Graphics.UserInterface
         }
 
         private Color4 glowColour;
+
         public Color4 GlowColour
         {
             get { return glowColour; }

osu.Game/Graphics/UserInterface/OsuDropdown.cs

@@ -17,6 +17,7 @@ namespace osu.Game.Graphics.UserInterface
     public class OsuDropdown<T> : Dropdown<T>, IHasAccentColour
     {
         private Color4 accentColour;
+
         public Color4 AccentColour
         {
             get { return accentColour; }
@@ -49,6 +50,7 @@ namespace osu.Game.Graphics.UserInterface
         protected override DropdownMenu CreateMenu() => new OsuDropdownMenu();
 
         #region OsuDropdownMenu
+
         protected class OsuDropdownMenu : DropdownMenu, IHasAccentColour
         {
             public override bool HandleNonPositionalInput => State == MenuState.Open;
@@ -83,6 +85,7 @@ namespace osu.Game.Graphics.UserInterface
             }
 
             private Color4 accentColour;
+
             public Color4 AccentColour
             {
                 get { return accentColour; }
@@ -97,12 +100,14 @@ namespace osu.Game.Graphics.UserInterface
             protected override DrawableMenuItem CreateDrawableMenuItem(MenuItem item) => new DrawableOsuDropdownMenuItem(item) { AccentColour = accentColour };
 
             #region DrawableOsuDropdownMenuItem
+
             public class DrawableOsuDropdownMenuItem : DrawableDropdownMenuItem, IHasAccentColour
             {
                 // IsHovered is used
                 public override bool HandlePositionalInput => true;
 
                 private Color4? accentColour;
+
                 public Color4 AccentColour
                 {
                     get { return accentColour ?? nonAccentSelectedColour; }
@@ -194,13 +199,16 @@ namespace osu.Game.Graphics.UserInterface
                     }
                 }
             }
+
             #endregion
         }
+
         #endregion
 
         public class OsuDropdownHeader : DropdownHeader, IHasAccentColour
         {
             protected readonly SpriteText Text;
+
             protected override string Label
             {
                 get { return Text.Text; }
@@ -210,6 +218,7 @@ namespace osu.Game.Graphics.UserInterface
             protected readonly SpriteIcon Icon;
 
             private Color4 accentColour;
+
             public virtual Color4 AccentColour
             {
                 get { return accentColour; }