Rework template usage

Includes moving the origin check back to templates, constructing nested template classes in each check, and making parameterized template usage.

osu.Game.Rulesets.Osu/Edit/Checks/CheckOffscreenObjects.cs

@@ -22,29 +22,46 @@ namespace osu.Game.Rulesets.Osu.Edit.Checks
         // (higher = more performant, but higher false-negative chance).
         private const int path_step_size = 5;
 
+        private readonly IssueTemplateOffscreenCircle templateOffscreenCircle;
+        private readonly IssueTemplateOffscreenSlider templateOffscreenSlider;
+        private readonly IssueTemplate[] templates;
+
+        private class IssueTemplateOffscreenCircle : IssueTemplate
+        {
+            public IssueTemplateOffscreenCircle(ICheck checkOrigin)
+                : base(checkOrigin, IssueType.Problem, "This circle goes offscreen on a 4:3 aspect ratio.")
+            {
+            }
+
+            public Issue Create(HitCircle circle) => new Issue(circle, this);
+        }
+
+        private class IssueTemplateOffscreenSlider : IssueTemplate
+        {
+            public IssueTemplateOffscreenSlider(ICheck checkOrigin)
+                : base(checkOrigin, IssueType.Problem, "This slider goes offscreen here on a 4:3 aspect ratio.")
+            {
+            }
+
+            public Issue Create(Slider slider, double offscreenTime) => new Issue(slider, this) { Time = offscreenTime };
+        }
+
+        public CheckOffscreenObjects()
+        {
+            templates = new IssueTemplate[]
+            {
+                templateOffscreenCircle = new IssueTemplateOffscreenCircle(this),
+                templateOffscreenSlider = new IssueTemplateOffscreenSlider(this)
+            };
+        }
+
         public CheckMetadata Metadata { get; } = new CheckMetadata
         (
             category: CheckCategory.Compose,
             description: "Offscreen hitobjects."
         );
 
-        public IEnumerable<IssueTemplate> PossibleTemplates => new[]
+        public IEnumerable<IssueTemplate> PossibleTemplates => templates;
-        {
-            templateOffscreen,
-            templateOffscreenSliderPath
-        };
-
-        private readonly IssueTemplate templateOffscreen = new IssueTemplate
-        (
-            type: IssueType.Problem,
-            unformattedMessage: "This object goes offscreen on a 4:3 aspect ratio."
-        );
-
-        private readonly IssueTemplate templateOffscreenSliderPath = new IssueTemplate
-        (
-            type: IssueType.Problem,
-            unformattedMessage: "This slider goes offscreen here on a 4:3 aspect ratio."
-        );
 
         public IEnumerable<Issue> Run(IBeatmap beatmap)
         {
@@ -63,7 +80,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Checks
                     case HitCircle circle:
                     {
                         if (isOffscreen(circle.StackedPosition, circle.Radius))
-                            yield return new Issue(this, circle, templateOffscreen);
+                            yield return templateOffscreenCircle.Create(circle);
 
                         break;
                     }
@@ -89,7 +106,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Checks
 
                 // `SpanDuration` ensures we don't include reverses.
                 double time = slider.StartTime + progress * slider.SpanDuration;
-                yield return new Issue(this, slider, templateOffscreenSliderPath) { Time = time };
+                yield return templateOffscreenSlider.Create(slider, time);
 
                 yield break;
             }
@@ -98,7 +115,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Checks
             if (!isOffscreen(slider.StackedEndPosition, slider.Radius))
                 yield break;
 
-            yield return new Issue(this, slider, templateOffscreenSliderPath) { Time = slider.EndTime };
+            yield return templateOffscreenSlider.Create(slider, slider.EndTime);
         }
 
         private bool isOffscreen(Vector2 position, double radius)

osu.Game/Rulesets/Edit/Checks/CheckBackground.cs

@@ -10,35 +10,52 @@ namespace osu.Game.Rulesets.Edit.Checks
 {
     public class CheckBackground : ICheck
     {
+        private readonly IssueTemplateNoneSet templateNoneSet;
+        private readonly IssueTemplateDoesNotExist templateDoesNotExist;
+        private readonly IssueTemplate[] templates;
+
+        private class IssueTemplateNoneSet : IssueTemplate
+        {
+            public IssueTemplateNoneSet(ICheck checkOrigin)
+                : base(checkOrigin, IssueType.Problem, "No background has been set")
+            {
+            }
+
+            public Issue Create() => new Issue(this);
+        }
+
+        private class IssueTemplateDoesNotExist : IssueTemplate
+        {
+            public IssueTemplateDoesNotExist(ICheck checkOrigin)
+                : base(checkOrigin, IssueType.Problem, "The background file \"{0}\" does not exist.")
+            {
+            }
+
+            public Issue Create(string filename) => new Issue(this, filename);
+        }
+
+        public CheckBackground()
+        {
+            templates = new IssueTemplate[]
+            {
+                templateNoneSet = new IssueTemplateNoneSet(this),
+                templateDoesNotExist = new IssueTemplateDoesNotExist(this)
+            };
+        }
+
         public CheckMetadata Metadata { get; } = new CheckMetadata
         (
             category: CheckCategory.Resources,
             description: "Missing background."
         );
 
-        public IEnumerable<IssueTemplate> PossibleTemplates => new[]
+        public IEnumerable<IssueTemplate> PossibleTemplates => templates;
-        {
-            templateNoneSet,
-            templateDoesNotExist
-        };
-
-        private readonly IssueTemplate templateNoneSet = new IssueTemplate
-        (
-            type: IssueType.Problem,
-            unformattedMessage: "No background has been set."
-        );
-
-        private readonly IssueTemplate templateDoesNotExist = new IssueTemplate
-        (
-            type: IssueType.Problem,
-            unformattedMessage: "The background file \"{0}\" is does not exist."
-        );
 
         public IEnumerable<Issue> Run(IBeatmap beatmap)
         {
             if (beatmap.Metadata.BackgroundFile == null)
             {
-                yield return new Issue(this, templateNoneSet);
+                yield return templateNoneSet.Create();
 
                 yield break;
             }
@@ -51,7 +68,7 @@ namespace osu.Game.Rulesets.Edit.Checks
             if (file != null)
                 yield break;
 
-            yield return new Issue(this, templateDoesNotExist, beatmap.Metadata.BackgroundFile);
+            yield return templateDoesNotExist.Create(beatmap.Metadata.BackgroundFile);
         }
     }
 }

osu.Game/Rulesets/Edit/Checks/Components/Issue.cs

@@ -29,7 +29,7 @@ namespace osu.Game.Rulesets.Edit.Checks.Components
         /// <summary>
         /// The check that this issue originates from.
         /// </summary>
-        public ICheck Check;
+        public ICheck Check => Template.Check;
 
         /// <summary>
         /// The arguments that give this issue its context, based on the <see cref="IssueTemplate"/>. These are then substituted into the <see cref="IssueTemplate.UnformattedMessage"/>.
@@ -37,30 +37,29 @@ namespace osu.Game.Rulesets.Edit.Checks.Components
         /// </summary>
         public object[] Arguments;
 
-        public Issue(ICheck check, IssueTemplate template, params object[] args)
+        public Issue(IssueTemplate template, params object[] args)
         {
-            Check = check;
             Time = null;
             HitObjects = Array.Empty<HitObject>();
             Template = template;
             Arguments = args;
         }
 
-        public Issue(ICheck check, double? time, IssueTemplate template, params object[] args)
+        public Issue(double? time, IssueTemplate template, params object[] args)
-            : this(check, template, args)
+            : this(template, args)
         {
             Time = time;
         }
 
-        public Issue(ICheck check, HitObject hitObject, IssueTemplate template, params object[] args)
+        public Issue(HitObject hitObject, IssueTemplate template, params object[] args)
-            : this(check, template, args)
+            : this(template, args)
         {
             Time = hitObject.StartTime;
             HitObjects = new[] { hitObject };
         }
 
-        public Issue(ICheck check, IEnumerable<HitObject> hitObjects, IssueTemplate template, params object[] args)
+        public Issue(IEnumerable<HitObject> hitObjects, IssueTemplate template, params object[] args)
-            : this(check, template, args)
+            : this(template, args)
         {
             var hitObjectList = hitObjects.ToList();
 

osu.Game/Rulesets/Edit/Checks/Components/IssueTemplate.cs

@@ -14,6 +14,11 @@ namespace osu.Game.Rulesets.Edit.Checks.Components
         private static readonly Color4 negligible_green = new Colour4(0.33f, 0.8f, 0.5f, 1.0f);
         private static readonly Color4 error_gray = new Colour4(0.5f, 0.5f, 0.5f, 1.0f);
 
+        /// <summary>
+        /// The check that this template originates from.
+        /// </summary>
+        public ICheck Check;
+
         /// <summary>
         /// The type of the issue.
         /// </summary>
@@ -26,8 +31,9 @@ namespace osu.Game.Rulesets.Edit.Checks.Components
         /// </summary>
         public readonly string UnformattedMessage;
 
-        public IssueTemplate(IssueType type, string unformattedMessage)
+        public IssueTemplate(ICheck check, IssueType type, string unformattedMessage)
         {
+            Check = check;
             Type = type;
             UnformattedMessage = unformattedMessage;
         }