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

362 lines
17 KiB
C#
Raw Normal View History

2019-01-25 02:11:04 +00:00
// 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.
2019-01-21 05:40:28 +00:00
using System;
using System.Collections.Generic;
using System.Linq;
using NUnit.Framework;
2019-02-21 12:27:41 +00:00
using osu.Framework.Screens;
2019-01-21 05:40:28 +00:00
using osu.Game.Beatmaps;
using osu.Game.Beatmaps.ControlPoints;
using osu.Game.Replays;
using osu.Game.Rulesets.Judgements;
using osu.Game.Rulesets.Objects;
using osu.Game.Rulesets.Objects.Types;
using osu.Game.Rulesets.Osu.Objects;
using osu.Game.Rulesets.Osu.Objects.Drawables;
using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
using osu.Game.Rulesets.Osu.Replays;
using osu.Game.Rulesets.Replays;
using osu.Game.Rulesets.Scoring;
using osu.Game.Scoring;
using osu.Game.Screens.Play;
using osu.Game.Tests.Visual;
using osuTK;
namespace osu.Game.Rulesets.Osu.Tests
{
public class TestSceneSliderInput : RateAdjustedBeatmapTestScene
2019-01-21 05:40:28 +00:00
{
public override IReadOnlyList<Type> RequiredTypes => new[]
{
typeof(SliderBall),
typeof(DrawableSlider),
typeof(DrawableSliderTick),
typeof(DrawableRepeatPoint),
2019-01-22 01:56:04 +00:00
typeof(DrawableOsuHitObject),
typeof(DrawableSliderHead),
typeof(DrawableSliderTail),
2019-01-21 05:40:28 +00:00
};
private const double time_before_slider = 250;
private const double time_slider_start = 1500;
private const double time_during_slide_1 = 2500;
private const double time_during_slide_2 = 3000;
private const double time_during_slide_3 = 3500;
private const double time_during_slide_4 = 3800;
private List<JudgementResult> judgementResults;
private bool allJudgedFired;
2019-01-21 05:40:28 +00:00
/// <summary>
2019-01-21 15:54:22 +00:00
/// Scenario:
/// - Press a key before a slider starts
/// - Press the other key on the slider head timed correctly while holding the original key
/// - Release the latter pressed key
2019-01-21 15:54:22 +00:00
/// Expected Result:
/// A passing test case will have the cursor lose tracking on replay frame 3.
2019-01-21 05:40:28 +00:00
/// </summary>
[Test]
2019-02-18 01:39:39 +00:00
public void TestInvalidKeyTransfer()
2019-01-21 05:40:28 +00:00
{
2019-02-18 01:39:39 +00:00
performTest(new List<ReplayFrame>
2019-01-21 05:40:28 +00:00
{
2019-02-18 01:39:39 +00:00
new OsuReplayFrame { Position = new Vector2(0, 0), Actions = { OsuAction.LeftButton }, Time = time_before_slider },
new OsuReplayFrame { Position = new Vector2(0, 0), Actions = { OsuAction.LeftButton, OsuAction.RightButton }, Time = time_slider_start },
new OsuReplayFrame { Position = new Vector2(0, 0), Actions = { OsuAction.LeftButton }, Time = time_during_slide_1 },
2019-01-21 05:40:28 +00:00
});
AddAssert("Tracking lost", assertMidSliderJudgementFail);
2019-01-21 05:40:28 +00:00
}
/// <summary>
2019-01-21 15:54:22 +00:00
/// Scenario:
/// - Press a key on the slider head timed correctly
/// - Press the other key in the middle of the slider while holding the original key
/// - Release the original key used to hit the slider
2019-01-21 15:54:22 +00:00
/// Expected Result:
/// A passing test case will have the cursor continue tracking on replay frame 3.
2019-01-21 05:40:28 +00:00
/// </summary>
[Test]
public void TestLeftBeforeSliderThenRightThenLettingGoOfLeft()
2019-01-21 05:40:28 +00:00
{
2019-02-18 01:39:39 +00:00
performTest(new List<ReplayFrame>
2019-01-21 05:40:28 +00:00
{
2019-02-18 01:39:39 +00:00
new OsuReplayFrame { Position = new Vector2(0, 0), Actions = { OsuAction.LeftButton }, Time = time_slider_start },
new OsuReplayFrame { Position = new Vector2(0, 0), Actions = { OsuAction.LeftButton, OsuAction.RightButton }, Time = time_during_slide_1 },
new OsuReplayFrame { Position = new Vector2(0, 0), Actions = { OsuAction.RightButton }, Time = time_during_slide_2 },
2019-01-21 05:40:28 +00:00
});
AddAssert("Tracking retained", assertGreatJudge);
2019-01-21 05:40:28 +00:00
}
/// <summary>
2019-01-21 15:54:22 +00:00
/// Scenario:
/// - Press a key on the slider head timed correctly
/// - Press the other key in the middle of the slider while holding the original key
/// - Release the new key that was pressed second
/// Expected Result:
2019-01-22 01:47:11 +00:00
/// A passing test case will have the cursor continue tracking on replay frame 3.
2019-01-21 05:40:28 +00:00
/// </summary>
[Test]
public void TestTrackingRetentionLeftRightLeft()
{
2019-02-18 01:39:39 +00:00
performTest(new List<ReplayFrame>
2019-01-21 05:40:28 +00:00
{
2019-02-18 01:39:39 +00:00
new OsuReplayFrame { Position = new Vector2(0, 0), Actions = { OsuAction.LeftButton }, Time = time_before_slider },
new OsuReplayFrame { Position = new Vector2(0, 0), Actions = { OsuAction.LeftButton, OsuAction.RightButton }, Time = time_slider_start },
new OsuReplayFrame { Position = new Vector2(0, 0), Actions = { OsuAction.RightButton }, Time = time_during_slide_1 },
2019-01-21 05:40:28 +00:00
});
AddAssert("Tracking retained", assertGreatJudge);
}
/// <summary>
2019-01-21 15:54:22 +00:00
/// Scenario:
/// - Press a key before a slider starts
/// - Press the other key on the slider head timed correctly while holding the original key
/// - Release the key that was held down before the slider started.
/// Expected Result:
2019-01-22 01:47:11 +00:00
/// A passing test case will have the cursor continue tracking on replay frame 3
2019-01-21 05:40:28 +00:00
/// </summary>
[Test]
public void TestTrackingLeftBeforeSliderToRight()
{
2019-02-18 01:39:39 +00:00
performTest(new List<ReplayFrame>
2019-01-21 05:40:28 +00:00
{
2019-02-18 01:39:39 +00:00
new OsuReplayFrame { Position = new Vector2(0, 0), Actions = { OsuAction.LeftButton }, Time = time_before_slider },
new OsuReplayFrame { Position = new Vector2(0, 0), Actions = { OsuAction.LeftButton, OsuAction.RightButton }, Time = time_slider_start },
new OsuReplayFrame { Position = new Vector2(0, 0), Actions = { OsuAction.RightButton }, Time = time_during_slide_1 },
2019-01-21 05:40:28 +00:00
});
AddAssert("Tracking retained", assertGreatJudge);
}
/// <summary>
2019-01-21 15:54:22 +00:00
/// Scenario:
/// - Press a key before a slider starts
/// - Hold the key down throughout the slider without pressing any other buttons.
/// Expected Result:
/// A passing test case will have the cursor track the slider, but miss the slider head.
2019-01-21 05:40:28 +00:00
/// </summary>
[Test]
public void TestTrackingPreclicked()
{
2019-02-18 01:39:39 +00:00
performTest(new List<ReplayFrame>
2019-01-21 05:40:28 +00:00
{
2019-02-18 01:39:39 +00:00
new OsuReplayFrame { Position = new Vector2(0, 0), Actions = { OsuAction.LeftButton }, Time = time_before_slider },
2019-01-21 05:40:28 +00:00
});
AddAssert("Tracking retained, sliderhead miss", assertHeadMissTailTracked);
2019-01-21 05:40:28 +00:00
}
/// <summary>
2019-01-21 15:54:22 +00:00
/// Scenario:
/// - Press a key before a slider starts
/// - Hold the key down after the slider starts
/// - Move the cursor away from the slider body
/// - Move the cursor back onto the body
/// Expected Result:
/// A passing test case will have the cursor track the slider, miss the head, miss the ticks where its outside of the body, and resume tracking when the cursor returns.
2019-01-21 05:40:28 +00:00
/// </summary>
[Test]
public void TestTrackingReturnMidSlider()
{
2019-02-18 01:39:39 +00:00
performTest(new List<ReplayFrame>
2019-01-21 05:40:28 +00:00
{
2019-02-18 01:39:39 +00:00
new OsuReplayFrame { Position = new Vector2(0, 0), Actions = { OsuAction.LeftButton }, Time = time_slider_start },
new OsuReplayFrame { Position = new Vector2(150, 150), Actions = { OsuAction.LeftButton }, Time = time_during_slide_1 },
new OsuReplayFrame { Position = new Vector2(200, 200), Actions = { OsuAction.LeftButton }, Time = time_during_slide_2 },
new OsuReplayFrame { Position = new Vector2(0, 0), Actions = { OsuAction.LeftButton }, Time = time_during_slide_3 },
new OsuReplayFrame { Position = new Vector2(0, 0), Actions = { OsuAction.LeftButton }, Time = time_during_slide_4 },
2019-01-21 05:40:28 +00:00
});
AddAssert("Tracking re-acquired", assertMidSliderJudgements);
}
/// <summary>
2019-01-21 15:54:22 +00:00
/// Scenario:
/// - Press a key before a slider starts
/// - Press the other key on the slider head timed correctly while holding the original key
/// - Release the key used to hit the slider head
/// - While holding the first key, move the cursor away from the slider body
/// - Still holding the first key, move the cursor back to the slider body
/// Expected Result:
/// A passing test case will have the slider not track despite having the cursor return to the slider body.
2019-01-21 05:40:28 +00:00
/// </summary>
[Test]
public void TestTrackingReturnMidSliderKeyDownBefore()
{
2019-02-18 01:39:39 +00:00
performTest(new List<ReplayFrame>
2019-01-21 05:40:28 +00:00
{
2019-02-18 01:39:39 +00:00
new OsuReplayFrame { Position = new Vector2(0, 0), Actions = { OsuAction.LeftButton }, Time = time_before_slider },
new OsuReplayFrame { Position = new Vector2(0, 0), Actions = { OsuAction.LeftButton, OsuAction.RightButton }, Time = time_slider_start },
new OsuReplayFrame { Position = new Vector2(0, 0), Actions = { OsuAction.LeftButton }, Time = time_during_slide_1 },
new OsuReplayFrame { Position = new Vector2(200, 200), Actions = { OsuAction.LeftButton }, Time = time_during_slide_2 },
new OsuReplayFrame { Position = new Vector2(0, 0), Actions = { OsuAction.LeftButton }, Time = time_during_slide_3 },
new OsuReplayFrame { Position = new Vector2(0, 0), Actions = { OsuAction.LeftButton }, Time = time_during_slide_4 },
2019-01-21 05:40:28 +00:00
});
AddAssert("Tracking lost", assertMidSliderJudgementFail);
}
/// <summary>
2019-01-21 15:54:22 +00:00
/// Scenario:
/// - Wait for the slider to reach a mid-point
/// - Press a key away from the slider body
/// - While holding down the key, move into the slider body
/// Expected Result:
/// A passing test case will have the slider track the cursor after the cursor enters the slider body.
2019-01-21 05:40:28 +00:00
/// </summary>
[Test]
public void TestTrackingMidSlider()
{
2019-02-18 01:39:39 +00:00
performTest(new List<ReplayFrame>
2019-01-21 05:40:28 +00:00
{
2019-02-18 01:39:39 +00:00
new OsuReplayFrame { Position = new Vector2(150, 150), Actions = { OsuAction.LeftButton }, Time = time_during_slide_1 },
new OsuReplayFrame { Position = new Vector2(200, 200), Actions = { OsuAction.LeftButton }, Time = time_during_slide_2 },
new OsuReplayFrame { Position = new Vector2(0, 0), Actions = { OsuAction.LeftButton }, Time = time_during_slide_3 },
new OsuReplayFrame { Position = new Vector2(0, 0), Actions = { OsuAction.LeftButton }, Time = time_during_slide_4 },
2019-01-21 05:40:28 +00:00
});
AddAssert("Tracking acquired", assertMidSliderJudgements);
}
/// <summary>
2019-01-21 15:54:22 +00:00
/// Scenario:
/// - Press a key before the slider starts
/// - Press another key on the slider head while holding the original key
/// - Move out of the slider body while releasing the two pressed keys
/// - Move back into the slider body while pressing any key.
/// Expected Result:
/// A passing test case will have the slider track the cursor after the cursor enters the slider body.
2019-01-21 05:40:28 +00:00
/// </summary>
[Test]
2019-02-18 01:39:39 +00:00
public void TestMidSliderTrackingAcquired()
2019-01-21 05:40:28 +00:00
{
2019-02-18 01:39:39 +00:00
performTest(new List<ReplayFrame>
2019-01-21 05:40:28 +00:00
{
2019-02-18 01:39:39 +00:00
new OsuReplayFrame { Position = new Vector2(0, 0), Actions = { OsuAction.LeftButton }, Time = time_before_slider },
new OsuReplayFrame { Position = new Vector2(0, 0), Actions = { OsuAction.LeftButton, OsuAction.RightButton }, Time = time_slider_start },
new OsuReplayFrame { Position = new Vector2(100, 100), Time = time_during_slide_1 },
new OsuReplayFrame { Position = new Vector2(0, 0), Actions = { OsuAction.LeftButton }, Time = time_during_slide_2 },
2019-01-21 05:40:28 +00:00
});
AddAssert("Tracking acquired", assertMidSliderJudgements);
}
2019-02-21 12:27:41 +00:00
[Test]
public void TestMidSliderTrackingAcquiredWithMouseDownOutsideSlider()
{
performTest(new List<ReplayFrame>
{
new OsuReplayFrame { Position = new Vector2(0, 0), Actions = { OsuAction.LeftButton }, Time = time_before_slider },
new OsuReplayFrame { Position = new Vector2(0, 0), Actions = { OsuAction.LeftButton, OsuAction.RightButton }, Time = time_slider_start },
new OsuReplayFrame { Position = new Vector2(100, 100), Actions = { OsuAction.RightButton }, Time = time_during_slide_1 },
new OsuReplayFrame { Position = new Vector2(0, 0), Actions = { OsuAction.RightButton }, Time = time_during_slide_2 },
});
AddAssert("Tracking acquired", assertMidSliderJudgements);
}
2019-01-21 05:40:28 +00:00
/// <summary>
2019-01-21 15:54:22 +00:00
/// Scenario:
/// - Press a key on the slider head
/// - While holding the key, move outside of the slider body with the cursor
/// - Release the key while outside of the slider body
/// - Press the key again while outside of the slider body
/// - Move back into the slider body while holding the pressed key
/// Expected Result:
/// A passing test case will have the slider track the cursor after the cursor enters the slider body.
2019-01-21 05:40:28 +00:00
/// </summary>
[Test]
2019-01-21 15:54:22 +00:00
public void TestTrackingReleasedValidKey()
2019-01-21 05:40:28 +00:00
{
2019-02-18 01:39:39 +00:00
performTest(new List<ReplayFrame>
2019-01-21 05:40:28 +00:00
{
2019-02-18 01:39:39 +00:00
new OsuReplayFrame { Position = new Vector2(0, 0), Actions = { OsuAction.LeftButton }, Time = time_slider_start },
new OsuReplayFrame { Position = new Vector2(100, 100), Actions = { OsuAction.LeftButton }, Time = time_during_slide_1 },
new OsuReplayFrame { Position = new Vector2(100, 100), Time = time_during_slide_2 },
new OsuReplayFrame { Position = new Vector2(100, 100), Actions = { OsuAction.LeftButton }, Time = time_during_slide_3 },
new OsuReplayFrame { Position = new Vector2(0, 0), Actions = { OsuAction.LeftButton }, Time = time_during_slide_4 },
2019-01-21 05:40:28 +00:00
});
AddAssert("Tracking acquired", assertMidSliderJudgements);
}
2019-02-18 01:39:39 +00:00
private bool assertGreatJudge() => judgementResults.Last().Type == HitResult.Great;
2019-12-14 12:54:22 +00:00
private bool assertHeadMissTailTracked() => judgementResults[^2].Type == HitResult.Great && judgementResults.First().Type == HitResult.Miss;
2019-01-21 05:40:28 +00:00
2019-12-14 12:54:22 +00:00
private bool assertMidSliderJudgements() => judgementResults[^2].Type == HitResult.Great;
2019-01-21 05:40:28 +00:00
2019-12-14 12:54:22 +00:00
private bool assertMidSliderJudgementFail() => judgementResults[^2].Type == HitResult.Miss;
2019-01-21 05:40:28 +00:00
private ScoreAccessibleReplayPlayer currentPlayer;
private void performTest(List<ReplayFrame> frames)
{
2019-02-19 05:28:53 +00:00
AddStep("load player", () =>
2019-01-22 01:49:54 +00:00
{
Beatmap.Value = CreateWorkingBeatmap(new Beatmap<OsuHitObject>
2019-02-21 12:27:41 +00:00
{
HitObjects =
{
new Slider
{
StartTime = time_slider_start,
Position = new Vector2(0, 0),
Path = new SliderPath(PathType.PerfectCurve, new[]
{
Vector2.Zero,
new Vector2(25, 0),
}, 25),
}
},
BeatmapInfo =
{
BaseDifficulty = new BeatmapDifficulty { SliderTickRate = 3 },
Ruleset = new OsuRuleset().RulesetInfo
},
});
2019-02-21 12:27:41 +00:00
2019-10-25 10:48:01 +00:00
Beatmap.Value.Beatmap.ControlPointInfo.Add(0, new DifficultyControlPoint { SpeedMultiplier = 0.1f });
var p = new ScoreAccessibleReplayPlayer(new Score { Replay = new Replay { Frames = frames } });
2019-02-19 05:28:53 +00:00
p.OnLoadComplete += _ =>
{
2019-02-19 05:28:53 +00:00
p.ScoreProcessor.NewJudgement += result =>
{
if (currentPlayer == p) judgementResults.Add(result);
};
p.ScoreProcessor.AllJudged += () =>
{
if (currentPlayer == p) allJudgedFired = true;
};
};
2019-02-18 01:39:39 +00:00
LoadScreen(currentPlayer = p);
2019-02-18 01:39:39 +00:00
allJudgedFired = false;
judgementResults = new List<JudgementResult>();
2019-01-24 06:52:20 +00:00
});
2019-02-21 12:27:41 +00:00
2019-03-19 08:24:26 +00:00
AddUntilStep("Beatmap at 0", () => Beatmap.Value.Track.CurrentTime == 0);
AddUntilStep("Wait until player is loaded", () => currentPlayer.IsCurrentScreen());
AddUntilStep("Wait for all judged", () => allJudgedFired);
2019-01-21 05:40:28 +00:00
}
private class ScoreAccessibleReplayPlayer : ReplayPlayer
{
public new ScoreProcessor ScoreProcessor => base.ScoreProcessor;
protected override bool PauseOnFocusLost => false;
2019-01-21 05:40:28 +00:00
public ScoreAccessibleReplayPlayer(Score score)
: base(score, false, false)
2019-01-21 05:40:28 +00:00
{
}
}
}
}