More general refactorings.

osu.Game.Modes.Catch/CatchRuleset.cs

@@ -82,13 +82,15 @@ namespace osu.Game.Modes.Catch
 
         public override FontAwesome Icon => FontAwesome.fa_osu_fruits_o;
 
-
+        public override IEnumerable<KeyCounter> CreateGameplayKeys()
-        public override KeyCounter[] CreateGameplayKeys => new KeyCounter[]
+        {
+            return new KeyCounter[]
             {
                 new KeyCounterKeyboard(Key.ShiftLeft),
                 new KeyCounterMouse(MouseButton.Left),
                 new KeyCounterMouse(MouseButton.Right)
             };
+        }
 
         public override ScoreProcessor CreateScoreProcessor(int hitObjectCount = 0) => null;
 

osu.Game.Modes.Mania/ManiaRuleset.cs

@@ -102,7 +102,10 @@ namespace osu.Game.Modes.Mania
 
         public override FontAwesome Icon => FontAwesome.fa_osu_mania_o;
 
-        public override KeyCounter[] CreateGameplayKeys => new KeyCounter[] { /* Todo: Should be keymod specific */ };
+        public override IEnumerable<KeyCounter> CreateGameplayKeys()
+        {
+            return new KeyCounter[] { /* Todo: Should be keymod specific */ };
+        }
 
         public override ScoreProcessor CreateScoreProcessor(int hitObjectCount = 0) => null;
 

osu.Game.Modes.Osu/OsuRuleset.cs

@@ -113,7 +113,10 @@ namespace osu.Game.Modes.Osu
         protected override PlayMode PlayMode => PlayMode.Osu;
 
         public override string Description => "osu!";
-        public override KeyCounter[] CreateGameplayKeys => new KeyCounter[]
+
+        public override IEnumerable<KeyCounter> CreateGameplayKeys()
+        {
+            return new KeyCounter[]
             {
                 new KeyCounterKeyboard(Key.Z),
                 new KeyCounterKeyboard(Key.X),
@@ -121,4 +124,5 @@ namespace osu.Game.Modes.Osu
                 new KeyCounterMouse(MouseButton.Right)
             };
         }
+    }
 }

osu.Game.Modes.Osu/OsuRuleset.cs.orig

@@ -0,0 +1,128 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using OpenTK.Input;
+using osu.Game.Beatmaps;
+using osu.Game.Graphics;
+using osu.Game.Modes.Objects;
+using osu.Game.Modes.Osu.Objects;
+using osu.Game.Modes.Osu.UI;
+using osu.Game.Modes.UI;
+using osu.Game.Screens.Play;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace osu.Game.Modes.Osu
+{
+    public class OsuRuleset : Ruleset
+    {
+        public override HitRenderer CreateHitRendererWith(Beatmap beatmap) => new OsuHitRenderer
+        {
+            Beatmap = beatmap,
+        };
+
+        public override IEnumerable<BeatmapStatistic> GetBeatmapStatistics(WorkingBeatmap beatmap) => new[]
+        {
+            new BeatmapStatistic
+            {
+                Name = @"Circle count",
+                Content = beatmap.Beatmap.HitObjects.Count(h => h is HitCircle).ToString(),
+                Icon = FontAwesome.fa_dot_circle_o
+            },
+            new BeatmapStatistic
+            {
+                Name = @"Slider count",
+                Content = beatmap.Beatmap.HitObjects.Count(h => h is Slider).ToString(),
+                Icon = FontAwesome.fa_circle_o
+            }
+        };
+
+        public override IEnumerable<Mod> GetModsFor(ModType type)
+        {
+            switch (type)
+            {
+                case ModType.DifficultyReduction:
+                    return new Mod[]
+                    {
+                        new OsuModEasy(),
+                        new OsuModNoFail(),
+                        new OsuModHalfTime(),
+                    };
+
+                case ModType.DifficultyIncrease:
+                    return new Mod[]
+                    {
+                        new OsuModHardRock(),
+                        new MultiMod
+                        {
+                            Mods = new Mod[]
+                            {
+                                new OsuModSuddenDeath(),
+                                new OsuModPerfect(),
+                            },
+                        },
+                        new MultiMod
+                        {
+                            Mods = new Mod[]
+                            {
+                                new OsuModDoubleTime(),
+                                new OsuModNightcore(),
+                            },
+                        },
+                        new OsuModHidden(),
+                        new OsuModFlashlight(),
+                    };
+
+                case ModType.Special:
+                    return new Mod[]
+                    {
+                        new OsuModRelax(),
+                        new OsuModAutopilot(),
+                        new OsuModSpunOut(),
+                        new MultiMod
+                        {
+                            Mods = new Mod[]
+                            {
+                                new OsuModAutoplay(),
+                                new ModCinema(),
+                            },
+                        },
+                        new OsuModTarget(),
+                    };
+
+                default:
+                    return new Mod[] { };
+            }
+        }
+
+        public override FontAwesome Icon => FontAwesome.fa_osu_osu_o;
+
+        public override HitObjectParser CreateHitObjectParser() => new OsuHitObjectParser();
+
+        public override ScoreProcessor CreateScoreProcessor(int hitObjectCount = 0) => new OsuScoreProcessor(hitObjectCount);
+
+        public override DifficultyCalculator CreateDifficultyCalculator(Beatmap beatmap) => new OsuDifficultyCalculator(beatmap);
+
+        public override Score CreateAutoplayScore(Beatmap beatmap)
+        {
+            var score = CreateScoreProcessor().GetScore();
+            score.Replay = new OsuAutoReplay(beatmap);
+            return score;
+        }
+
+        protected override PlayMode PlayMode => PlayMode.Osu;
+
+        public override string Description => "osu!";
+<<<<<<< HEAD
+        public override KeyCounter[] CreateGameplayKeys => new KeyCounter[]
+=======
+        public override KeyCounter[] GameplayKeys => new KeyCounter[]
+>>>>>>> combocounter_bindable
+        {
+            new KeyCounterKeyboard(Key.Z),
+            new KeyCounterKeyboard(Key.X),
+            new KeyCounterMouse(MouseButton.Left),
+            new KeyCounterMouse(MouseButton.Right)
+        };
+    }
+}

osu.Game.Modes.Taiko/TaikoRuleset.cs

@@ -82,13 +82,16 @@ namespace osu.Game.Modes.Taiko
 
         public override FontAwesome Icon => FontAwesome.fa_osu_taiko_o;
 
-        public override KeyCounter[] CreateGameplayKeys => new KeyCounter[]
+        public override IEnumerable<KeyCounter> CreateGameplayKeys()
+        {
+            return new KeyCounter[]
             {
                 new KeyCounterKeyboard(Key.D),
                 new KeyCounterKeyboard(Key.F),
                 new KeyCounterKeyboard(Key.J),
                 new KeyCounterKeyboard(Key.K)
             };
+        }
 
         public override ScoreProcessor CreateScoreProcessor(int hitObjectCount = 0) => null;
 

osu.Game/Modes/Ruleset.cs

@@ -21,13 +21,10 @@ namespace osu.Game.Modes
 
     public abstract class Ruleset
     {
-        public abstract KeyCounter[] CreateGameplayKeys { get; }
-
         private static ConcurrentDictionary<PlayMode, Type> availableRulesets = new ConcurrentDictionary<PlayMode, Type>();
 
         public static IEnumerable<PlayMode> PlayModes => availableRulesets.Keys;
 
-
         public virtual IEnumerable<BeatmapStatistic> GetBeatmapStatistics(WorkingBeatmap beatmap) => new BeatmapStatistic[] { };
 
         public abstract IEnumerable<Mod> GetModsFor(ModType type);
@@ -48,6 +45,8 @@ namespace osu.Game.Modes
 
         public abstract string Description { get; }
 
+        public abstract IEnumerable<KeyCounter> CreateGameplayKeys();
+
         public virtual Score CreateAutoplayScore(Beatmap beatmap) => null;
 
         public static Ruleset GetRuleset(PlayMode mode)

osu.Game/Modes/Ruleset.cs.orig

@@ -0,0 +1,69 @@
+// 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.Beatmaps;
+using osu.Game.Graphics;
+using osu.Game.Modes.Objects;
+using osu.Game.Modes.UI;
+using osu.Game.Screens.Play;
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+
+namespace osu.Game.Modes
+{
+    public class BeatmapStatistic
+    {
+        public FontAwesome Icon;
+        public string Content;
+        public string Name;
+    }
+
+    public abstract class Ruleset
+    {
+        public abstract KeyCounter[] CreateGameplayKeys { get; }
+
+        private static ConcurrentDictionary<PlayMode, Type> availableRulesets = new ConcurrentDictionary<PlayMode, Type>();
+<<<<<<< HEAD
+
+        public static IEnumerable<PlayMode> PlayModes => availableRulesets.Keys;
+=======
+
+        public static IEnumerable<PlayMode> PlayModes => availableRulesets.Keys;
+
+>>>>>>> combocounter_bindable
+
+        public virtual IEnumerable<BeatmapStatistic> GetBeatmapStatistics(WorkingBeatmap beatmap) => new BeatmapStatistic[] { };
+
+        public abstract IEnumerable<Mod> GetModsFor(ModType type);
+
+        public abstract ScoreProcessor CreateScoreProcessor(int hitObjectCount = 0);
+
+        public abstract HitRenderer CreateHitRendererWith(Beatmap beatmap);
+
+        public abstract HitObjectParser CreateHitObjectParser();
+
+        public abstract DifficultyCalculator CreateDifficultyCalculator(Beatmap beatmap);
+
+        public static void Register(Ruleset ruleset) => availableRulesets.TryAdd(ruleset.PlayMode, ruleset.GetType());
+
+        protected abstract PlayMode PlayMode { get; }
+
+        public virtual FontAwesome Icon => FontAwesome.fa_question_circle;
+
+        public abstract string Description { get; }
+
+        public virtual Score CreateAutoplayScore(Beatmap beatmap) => null;
+
+        public static Ruleset GetRuleset(PlayMode mode)
+        {
+            Type type;
+
+            if (!availableRulesets.TryGetValue(mode, out type))
+                return null;
+
+            return Activator.CreateInstance(type) as Ruleset;
+        }
+
+    }
+}

osu.Game/Modes/UI/HUDOverlay.cs

@@ -14,7 +14,7 @@ using System.Collections.Generic;
 
 namespace osu.Game.Modes.UI
 {
-    internal abstract class HudOverlay : Container
+    public abstract class HudOverlay : Container
     {
         public readonly KeyCounterCollection KeyCounter;
         public readonly ComboCounter ComboCounter;
@@ -49,7 +49,7 @@ namespace osu.Game.Modes.UI
 
             Children = new Drawable[]
             {
-                KeyCounter = CreateKeyCounter(ruleset.CreateGameplayKeys),
+                KeyCounter = CreateKeyCounter(ruleset.CreateGameplayKeys()),
                 ComboCounter = CreateComboCounter(),
                 ScoreCounter = CreateScoreCounter(),
                 AccuracyCounter = CreateAccuracyCounter(),

osu.Game/Modes/UI/HealthDisplay.cs

@@ -6,7 +6,7 @@ using osu.Framework.Graphics.Containers;
 
 namespace osu.Game.Modes.UI
 {
-    internal abstract class HealthDisplay : Container
+    public abstract class HealthDisplay : Container
     {
         public readonly BindableDouble Current = new BindableDouble
         {

osu.Game/Modes/UI/StandardHUDOverlay.cs

@@ -1,7 +1,6 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-
 using OpenTK;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Primitives;
@@ -11,7 +10,7 @@ using System.Collections.Generic;
 
 namespace osu.Game.Modes.UI
 {
-    internal class StandardHudOverlay : HudOverlay
+    public class StandardHudOverlay : HudOverlay
     {
         public StandardHudOverlay(Ruleset ruleset)
             : base(ruleset)

osu.Game/Modes/UI/StandardHealthDisplay.cs

@@ -14,7 +14,7 @@ using osu.Game.Graphics;
 
 namespace osu.Game.Modes.UI
 {
-    internal class StandardHealthDisplay : HealthDisplay
+    public class StandardHealthDisplay : HealthDisplay
     {
         private Container fill;