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
{
2019-05-14 19:37:25 +00:00
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 ) ,
2019-01-24 09:24:13 +00:00
typeof ( DrawableSliderTail ) ,
2019-01-21 05:40:28 +00:00
} ;
2019-01-25 02:13:37 +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 ;
2019-02-19 03:06:49 +00:00
private const double time_during_slide_4 = 3800 ;
2019-01-25 02:13:37 +00:00
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:
2019-01-24 09:24:13 +00:00
/// - 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:
2019-01-24 09:24:13 +00:00
/// 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
} ) ;
2019-01-24 09:24:13 +00:00
AddAssert ( "Tracking lost" , assertMidSliderJudgementFail ) ;
2019-01-21 05:40:28 +00:00
}
/// <summary>
2019-01-21 15:54:22 +00:00
/// Scenario:
2019-01-24 09:24:13 +00:00
/// - 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:
2019-01-24 09:24:13 +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]
2019-01-24 09:24:13 +00:00
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
} ) ;
2019-01-24 09:24:13 +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
} ) ;
2019-01-24 09:24:13 +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-01-24 15:07:33 +00:00
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
2019-02-19 04:58:05 +00:00
private ScoreAccessibleReplayPlayer currentPlayer ;
2019-01-24 07:56:42 +00:00
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
{
2019-05-31 05:40:53 +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-05-31 05:40:53 +00:00
} ) ;
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 } ) ;
2019-03-26 07:53:44 +00:00
var p = new ScoreAccessibleReplayPlayer ( new Score { Replay = new Replay { Frames = frames } } ) ;
2019-02-19 05:28:53 +00:00
p . OnLoadComplete + = _ = >
2019-02-19 04:58:05 +00:00
{
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-19 04:58:05 +00:00
} ;
2019-02-18 01:39:39 +00:00
2019-02-19 04:58:05 +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 ;
2019-05-10 06:39:25 +00:00
protected override bool PauseOnFocusLost = > false ;
2019-01-21 05:40:28 +00:00
public ScoreAccessibleReplayPlayer ( Score score )
2019-03-26 07:53:44 +00:00
: base ( score , false , false )
2019-01-21 05:40:28 +00:00
{
}
}
}
}