Merge pull request #23317 from cdwcgt/acc-challenge

Provide more accuracy modes for accuracy challenge mod

osu.Game.Tests/Visual/Mods/TestSceneModAccuracyChallenge.cs

@@ -0,0 +1,69 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Osu.Objects;
+using osuTK;
+
+namespace osu.Game.Tests.Visual.Mods
+{
+    public partial class TestSceneModAccuracyChallenge : ModTestScene
+    {
+        protected override Ruleset CreatePlayerRuleset() => new OsuRuleset();
+
+        protected override TestPlayer CreateModPlayer(Ruleset ruleset)
+        {
+            var player = base.CreateModPlayer(ruleset);
+            return player;
+        }
+
+        protected override bool AllowFail => true;
+
+        [Test]
+        public void TestMaximumAchievableAccuracy() =>
+            CreateModTest(new ModTestData
+            {
+                Mod = new ModAccuracyChallenge
+                {
+                    MinimumAccuracy = { Value = 0.6 }
+                },
+                Autoplay = false,
+                Beatmap = new Beatmap
+                {
+                    HitObjects = Enumerable.Range(0, 5).Select(i => new HitCircle
+                    {
+                        StartTime = i * 250,
+                        Position = new Vector2(i * 50)
+                    }).Cast<HitObject>().ToList()
+                },
+                PassCondition = () => Player.GameplayState.HasFailed && Player.ScoreProcessor.JudgedHits >= 3
+            });
+
+        [Test]
+        public void TestStandardAccuracy() =>
+            CreateModTest(new ModTestData
+            {
+                Mod = new ModAccuracyChallenge
+                {
+                    MinimumAccuracy = { Value = 0.6 },
+                    AccuracyJudgeMode = { Value = ModAccuracyChallenge.AccuracyMode.Standard }
+                },
+                Autoplay = false,
+                Beatmap = new Beatmap
+                {
+                    HitObjects = Enumerable.Range(0, 5).Select(i => new HitCircle
+                    {
+                        StartTime = i * 250,
+                        Position = new Vector2(i * 50)
+                    }).Cast<HitObject>().ToList()
+                },
+                PassCondition = () => Player.GameplayState.HasFailed && Player.ScoreProcessor.JudgedHits >= 1
+            });
+    }
+}

osu.Game/Rulesets/Mods/ModAccuracyChallenge.cs

@@ -7,6 +7,7 @@ using System.Linq;
 using osu.Framework.Bindables;
 using osu.Framework.Localisation;
 using osu.Game.Configuration;
+using osu.Game.Localisation.HUD;
 using osu.Game.Overlays.Settings;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Judgements;
@@ -42,30 +43,44 @@ namespace osu.Game.Rulesets.Mods
             Value = 0.9,
         };
 
-        private ScoreProcessor scoreProcessor = null!;
+        [SettingSource("Accuracy mode", "The mode of accuracy that will trigger failure.")]
+        public Bindable<AccuracyMode> AccuracyJudgeMode { get; } = new Bindable<AccuracyMode>();
 
-        public void ApplyToScoreProcessor(ScoreProcessor scoreProcessor) => this.scoreProcessor = scoreProcessor;
+        private readonly Bindable<double> currentAccuracy = new Bindable<double>();
+
+        public void ApplyToScoreProcessor(ScoreProcessor scoreProcessor)
+        {
+            switch (AccuracyJudgeMode.Value)
+            {
+                case AccuracyMode.Standard:
+                    currentAccuracy.BindTo(scoreProcessor.Accuracy);
+                    break;
+
+                case AccuracyMode.MaximumAchievable:
+                    currentAccuracy.BindTo(scoreProcessor.MaximumAccuracy);
+                    break;
+            }
+
+            currentAccuracy.BindValueChanged(s =>
+            {
+                if (s.NewValue < MinimumAccuracy.Value)
+                {
+                    TriggerFailure();
+                }
+            });
+        }
 
         public ScoreRank AdjustRank(ScoreRank rank, double accuracy) => rank;
 
-        protected override bool FailCondition(HealthProcessor healthProcessor, JudgementResult result)
+        protected override bool FailCondition(HealthProcessor healthProcessor, JudgementResult result) => false;
+
+        public enum AccuracyMode
         {
-            if (!result.Type.AffectsAccuracy())
+            [LocalisableDescription(typeof(GameplayAccuracyCounterStrings), nameof(GameplayAccuracyCounterStrings.AccuracyDisplayModeMax))]
-                return false;
+            MaximumAchievable,
 
-            return getAccuracyWithImminentResultAdded(result) < MinimumAccuracy.Value;
+            [LocalisableDescription(typeof(GameplayAccuracyCounterStrings), nameof(GameplayAccuracyCounterStrings.AccuracyDisplayModeStandard))]
-        }
+            Standard,
-
-        private double getAccuracyWithImminentResultAdded(JudgementResult result)
-        {
-            var score = new ScoreInfo { Ruleset = scoreProcessor.Ruleset.RulesetInfo };
-
-            // This is super ugly, but if we don't do it this way we will not have the most recent result added to the accuracy value.
-            // Hopefully we can improve this in the future.
-            scoreProcessor.PopulateScore(score);
-            score.Statistics[result.Type]++;
-
-            return scoreProcessor.ComputeAccuracy(score);
         }
     }
 }