1
0
mirror of https://github.com/ppy/osu.git synced 2024-12-16 03:02:53 +08:00
osu-lazer/osu.Game.Rulesets.Osu.Tests/TestSceneSlider.cs

358 lines
14 KiB
C#
Raw Normal View History

// 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.
2018-04-13 17:19:50 +08:00
using System;
using System.Collections.Generic;
using osu.Framework.Graphics;
using osu.Framework.Graphics.Containers;
using osu.Game.Audio;
using osu.Game.Beatmaps;
using osu.Game.Beatmaps.ControlPoints;
using osu.Game.Rulesets.Osu.Objects;
using osu.Game.Rulesets.Osu.Objects.Drawables;
2018-11-20 15:51:59 +08:00
using osuTK;
using osuTK.Graphics;
2018-04-13 17:19:50 +08:00
using osu.Game.Rulesets.Mods;
using System.Linq;
using NUnit.Framework;
using osu.Game.Graphics;
2018-04-13 17:19:50 +08:00
using osu.Game.Graphics.Sprites;
using osu.Game.Rulesets.Judgements;
using osu.Game.Rulesets.Objects;
2018-04-13 17:19:50 +08:00
using osu.Game.Rulesets.Objects.Drawables;
using osu.Game.Rulesets.Objects.Types;
using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
namespace osu.Game.Rulesets.Osu.Tests
{
[TestFixture]
2019-08-20 12:18:59 +08:00
public class TestSceneSlider : SkinnableTestScene
2018-04-13 17:19:50 +08:00
{
public override IReadOnlyList<Type> RequiredTypes => new[]
{
2019-08-20 12:18:59 +08:00
typeof(Slider),
typeof(SliderTick),
typeof(SliderTailCircle),
2018-04-13 17:19:50 +08:00
typeof(SliderBall),
typeof(SliderBody),
2019-08-20 12:18:59 +08:00
typeof(SnakingSliderBody),
2018-04-13 17:19:50 +08:00
typeof(DrawableSlider),
typeof(DrawableSliderTick),
2019-08-20 12:18:59 +08:00
typeof(DrawableSliderTail),
typeof(DrawableSliderHead),
2018-04-13 17:19:50 +08:00
typeof(DrawableRepeatPoint),
typeof(DrawableOsuHitObject)
};
2019-08-20 12:18:59 +08:00
private Container content;
protected override Container<Drawable> Content
{
get
{
if (content == null)
base.Content.Add(content = new OsuInputManager(new RulesetInfo { ID = 0 }));
return content;
}
}
2018-04-13 17:19:50 +08:00
private int depthIndex;
public TestSceneSlider()
2018-04-13 17:19:50 +08:00
{
2019-08-20 12:18:59 +08:00
AddStep("Big Single", () => SetContents(() => testSimpleBig()));
AddStep("Medium Single", () => SetContents(() => testSimpleMedium()));
AddStep("Small Single", () => SetContents(() => testSimpleSmall()));
AddStep("Big 1 Repeat", () => SetContents(() => testSimpleBig(1)));
AddStep("Medium 1 Repeat", () => SetContents(() => testSimpleMedium(1)));
AddStep("Small 1 Repeat", () => SetContents(() => testSimpleSmall(1)));
AddStep("Big 2 Repeats", () => SetContents(() => testSimpleBig(2)));
AddStep("Medium 2 Repeats", () => SetContents(() => testSimpleMedium(2)));
AddStep("Small 2 Repeats", () => SetContents(() => testSimpleSmall(2)));
AddStep("Slow Slider", () => SetContents(testSlowSpeed)); // slow long sliders take ages already so no repeat steps
AddStep("Slow Short Slider", () => SetContents(() => testShortSlowSpeed()));
AddStep("Slow Short Slider 1 Repeats", () => SetContents(() => testShortSlowSpeed(1)));
AddStep("Slow Short Slider 2 Repeats", () => SetContents(() => testShortSlowSpeed(2)));
AddStep("Fast Slider", () => SetContents(() => testHighSpeed()));
AddStep("Fast Slider 1 Repeat", () => SetContents(() => testHighSpeed(1)));
AddStep("Fast Slider 2 Repeats", () => SetContents(() => testHighSpeed(2)));
AddStep("Fast Short Slider", () => SetContents(() => testShortHighSpeed()));
AddStep("Fast Short Slider 1 Repeat", () => SetContents(() => testShortHighSpeed(1)));
AddStep("Fast Short Slider 2 Repeats", () => SetContents(() => testShortHighSpeed(2)));
AddStep("Fast Short Slider 6 Repeats", () => SetContents(() => testShortHighSpeed(6)));
AddStep("Perfect Curve", () => SetContents(() => testPerfect()));
AddStep("Perfect Curve 1 Repeat", () => SetContents(() => testPerfect(1)));
AddStep("Perfect Curve 2 Repeats", () => SetContents(() => testPerfect(2)));
AddStep("Linear Slider", () => SetContents(() => testLinear()));
AddStep("Linear Slider 1 Repeat", () => SetContents(() => testLinear(1)));
AddStep("Linear Slider 2 Repeats", () => SetContents(() => testLinear(2)));
AddStep("Bezier Slider", () => SetContents(() => testBezier()));
AddStep("Bezier Slider 1 Repeat", () => SetContents(() => testBezier(1)));
AddStep("Bezier Slider 2 Repeats", () => SetContents(() => testBezier(2)));
AddStep("Linear Overlapping", () => SetContents(() => testLinearOverlapping()));
AddStep("Linear Overlapping 1 Repeat", () => SetContents(() => testLinearOverlapping(1)));
AddStep("Linear Overlapping 2 Repeats", () => SetContents(() => testLinearOverlapping(2)));
AddStep("Catmull Slider", () => SetContents(() => testCatmull()));
AddStep("Catmull Slider 1 Repeat", () => SetContents(() => testCatmull(1)));
AddStep("Catmull Slider 2 Repeats", () => SetContents(() => testCatmull(2)));
AddStep("Big Single, Large StackOffset", () => SetContents(() => testSimpleBigLargeStackOffset()));
AddStep("Big 1 Repeat, Large StackOffset", () => SetContents(() => testSimpleBigLargeStackOffset(1)));
AddStep("Distance Overflow", () => SetContents(() => testDistanceOverflow()));
AddStep("Distance Overflow 1 Repeat", () => SetContents(() => testDistanceOverflow(1)));
2018-04-13 17:19:50 +08:00
}
[Test]
public void TestChangeStackHeight()
{
DrawableSlider slider = null;
AddStep("create slider", () =>
{
slider = (DrawableSlider)createSlider(repeats: 1);
Add(slider);
});
AddStep("change stack height", () => slider.HitObject.StackHeight = 10);
AddAssert("body positioned correctly", () => slider.Position == slider.HitObject.StackedPosition);
}
2019-08-20 12:18:59 +08:00
private Drawable testSimpleBig(int repeats = 0) => createSlider(2, repeats: repeats);
2018-04-13 17:19:50 +08:00
2019-08-20 12:18:59 +08:00
private Drawable testSimpleBigLargeStackOffset(int repeats = 0) => createSlider(2, repeats: repeats, stackHeight: 10);
2018-04-13 17:19:50 +08:00
2019-08-20 12:18:59 +08:00
private Drawable testDistanceOverflow(int repeats = 0)
{
var slider = new Slider
{
StartTime = Time.Current + 1000,
Position = new Vector2(239, 176),
Path = new SliderPath(PathType.PerfectCurve, new[]
{
Vector2.Zero,
new Vector2(154, 28),
new Vector2(52, -34)
}, 700),
RepeatCount = repeats,
NodeSamples = createEmptySamples(repeats),
StackHeight = 10
};
2019-08-20 12:18:59 +08:00
return createDrawable(slider, 2, 2);
}
2019-08-20 12:18:59 +08:00
private Drawable testSimpleMedium(int repeats = 0) => createSlider(5, repeats: repeats);
2018-04-13 17:19:50 +08:00
2019-08-20 12:18:59 +08:00
private Drawable testSimpleSmall(int repeats = 0) => createSlider(7, repeats: repeats);
2018-04-13 17:19:50 +08:00
2019-08-20 12:18:59 +08:00
private Drawable testSlowSpeed() => createSlider(speedMultiplier: 0.5);
2018-04-13 17:19:50 +08:00
2019-08-20 12:18:59 +08:00
private Drawable testShortSlowSpeed(int repeats = 0) => createSlider(distance: 100, repeats: repeats, speedMultiplier: 0.5);
2018-04-13 17:19:50 +08:00
2019-08-20 12:18:59 +08:00
private Drawable testHighSpeed(int repeats = 0) => createSlider(repeats: repeats, speedMultiplier: 15);
2018-04-13 17:19:50 +08:00
2019-08-20 12:18:59 +08:00
private Drawable testShortHighSpeed(int repeats = 0) => createSlider(distance: 100, repeats: repeats, speedMultiplier: 15);
2018-04-13 17:19:50 +08:00
2019-08-20 12:18:59 +08:00
private Drawable createSlider(float circleSize = 2, float distance = 400, int repeats = 0, double speedMultiplier = 2, int stackHeight = 0)
2018-04-13 17:19:50 +08:00
{
var slider = new Slider
{
StartTime = Time.Current + 1000,
Position = new Vector2(-(distance / 2), 0),
Path = new SliderPath(PathType.PerfectCurve, new[]
2018-04-13 17:19:50 +08:00
{
Vector2.Zero,
new Vector2(distance, 0),
}, distance),
2018-04-13 17:19:50 +08:00
RepeatCount = repeats,
NodeSamples = createEmptySamples(repeats),
2018-04-13 17:19:50 +08:00
StackHeight = stackHeight
};
2019-08-20 12:18:59 +08:00
return createDrawable(slider, circleSize, speedMultiplier);
2018-04-13 17:19:50 +08:00
}
2019-08-20 12:18:59 +08:00
private Drawable testPerfect(int repeats = 0)
2018-04-13 17:19:50 +08:00
{
var slider = new Slider
{
StartTime = Time.Current + 1000,
Position = new Vector2(-200, 0),
Path = new SliderPath(PathType.PerfectCurve, new[]
2018-04-13 17:19:50 +08:00
{
Vector2.Zero,
new Vector2(200, 200),
new Vector2(400, 0)
}, 600),
2018-04-13 17:19:50 +08:00
RepeatCount = repeats,
NodeSamples = createEmptySamples(repeats)
2018-04-13 17:19:50 +08:00
};
2019-08-20 12:18:59 +08:00
return createDrawable(slider, 2, 3);
2018-04-13 17:19:50 +08:00
}
2019-08-20 12:18:59 +08:00
private Drawable testLinear(int repeats = 0) => createLinear(repeats);
2018-04-13 17:19:50 +08:00
2019-08-20 12:18:59 +08:00
private Drawable createLinear(int repeats)
2018-04-13 17:19:50 +08:00
{
var slider = new Slider
{
StartTime = Time.Current + 1000,
Position = new Vector2(-200, 0),
Path = new SliderPath(PathType.Linear, new[]
2018-04-13 17:19:50 +08:00
{
Vector2.Zero,
new Vector2(150, 75),
new Vector2(200, 0),
new Vector2(300, -200),
new Vector2(400, 0),
new Vector2(430, 0)
}),
2018-04-13 17:19:50 +08:00
RepeatCount = repeats,
NodeSamples = createEmptySamples(repeats)
2018-04-13 17:19:50 +08:00
};
2019-08-20 12:18:59 +08:00
return createDrawable(slider, 2, 3);
2018-04-13 17:19:50 +08:00
}
2019-08-20 12:18:59 +08:00
private Drawable testBezier(int repeats = 0) => createBezier(repeats);
2018-04-13 17:19:50 +08:00
2019-08-20 12:18:59 +08:00
private Drawable createBezier(int repeats)
2018-04-13 17:19:50 +08:00
{
var slider = new Slider
{
StartTime = Time.Current + 1000,
Position = new Vector2(-200, 0),
Path = new SliderPath(PathType.Bezier, new[]
2018-04-13 17:19:50 +08:00
{
Vector2.Zero,
new Vector2(150, 75),
new Vector2(200, 100),
new Vector2(300, -200),
new Vector2(430, 0)
}),
2018-04-13 17:19:50 +08:00
RepeatCount = repeats,
NodeSamples = createEmptySamples(repeats)
2018-04-13 17:19:50 +08:00
};
2019-08-20 12:18:59 +08:00
return createDrawable(slider, 2, 3);
2018-04-13 17:19:50 +08:00
}
2019-08-20 12:18:59 +08:00
private Drawable testLinearOverlapping(int repeats = 0) => createOverlapping(repeats);
2018-04-13 17:19:50 +08:00
2019-08-20 12:18:59 +08:00
private Drawable createOverlapping(int repeats)
2018-04-13 17:19:50 +08:00
{
var slider = new Slider
{
StartTime = Time.Current + 1000,
Position = new Vector2(0, 0),
Path = new SliderPath(PathType.Linear, new[]
2018-04-13 17:19:50 +08:00
{
Vector2.Zero,
new Vector2(-200, 0),
new Vector2(0, 0),
new Vector2(0, -200),
new Vector2(-200, -200),
new Vector2(0, -200)
}),
2018-04-13 17:19:50 +08:00
RepeatCount = repeats,
NodeSamples = createEmptySamples(repeats)
2018-04-13 17:19:50 +08:00
};
2019-08-20 12:18:59 +08:00
return createDrawable(slider, 2, 3);
2018-04-13 17:19:50 +08:00
}
2019-08-20 12:18:59 +08:00
private Drawable testCatmull(int repeats = 0) => createCatmull(repeats);
2018-04-13 17:19:50 +08:00
2019-08-20 12:18:59 +08:00
private Drawable createCatmull(int repeats = 0)
2018-04-13 17:19:50 +08:00
{
2019-06-30 20:58:30 +08:00
var repeatSamples = new List<List<HitSampleInfo>>();
2018-04-13 17:19:50 +08:00
for (int i = 0; i < repeats; i++)
2019-06-30 20:58:30 +08:00
repeatSamples.Add(new List<HitSampleInfo>());
2018-04-13 17:19:50 +08:00
var slider = new Slider
{
StartTime = Time.Current + 1000,
Position = new Vector2(-100, 0),
Path = new SliderPath(PathType.Catmull, new[]
2018-04-13 17:19:50 +08:00
{
Vector2.Zero,
new Vector2(50, -50),
new Vector2(150, 50),
new Vector2(200, 0)
}),
2018-04-13 17:19:50 +08:00
RepeatCount = repeats,
NodeSamples = repeatSamples
2018-04-13 17:19:50 +08:00
};
2019-08-20 12:18:59 +08:00
return createDrawable(slider, 3, 1);
2018-04-13 17:19:50 +08:00
}
2019-06-30 20:58:30 +08:00
private List<List<HitSampleInfo>> createEmptySamples(int repeats)
2018-04-13 17:19:50 +08:00
{
2019-06-30 20:58:30 +08:00
var repeatSamples = new List<List<HitSampleInfo>>();
2018-04-13 17:19:50 +08:00
for (int i = 0; i < repeats; i++)
2019-06-30 20:58:30 +08:00
repeatSamples.Add(new List<HitSampleInfo>());
2018-04-13 17:19:50 +08:00
return repeatSamples;
}
2019-08-20 12:18:59 +08:00
private Drawable createDrawable(Slider slider, float circleSize, double speedMultiplier)
2018-04-13 17:19:50 +08:00
{
var cpi = new ControlPointInfo();
2019-10-25 18:48:01 +08:00
cpi.Add(0, new DifficultyControlPoint { SpeedMultiplier = speedMultiplier });
2018-04-13 17:19:50 +08:00
slider.ApplyDefaults(cpi, new BeatmapDifficulty { CircleSize = circleSize, SliderTickRate = 3 });
2019-09-26 16:39:26 +08:00
var drawable = CreateDrawableSlider(slider);
2018-04-13 17:19:50 +08:00
2019-04-10 11:03:57 +08:00
foreach (var mod in Mods.Value.OfType<IApplicableToDrawableHitObjects>())
2018-04-13 17:19:50 +08:00
mod.ApplyToDrawableHitObjects(new[] { drawable });
drawable.OnNewResult += onNewResult;
2018-04-13 17:19:50 +08:00
2019-08-20 12:18:59 +08:00
return drawable;
2018-04-13 17:19:50 +08:00
}
2019-09-26 16:39:26 +08:00
protected virtual DrawableSlider CreateDrawableSlider(Slider slider) => new DrawableSlider(slider)
{
Anchor = Anchor.Centre,
Depth = depthIndex++
};
2018-04-13 17:19:50 +08:00
private float judgementOffsetDirection = 1;
2019-02-28 12:31:40 +08:00
private void onNewResult(DrawableHitObject judgedObject, JudgementResult result)
2018-04-13 17:19:50 +08:00
{
var osuObject = judgedObject as DrawableOsuHitObject;
if (osuObject == null)
return;
OsuSpriteText text;
Add(text = new OsuSpriteText
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
Text = result.IsHit ? "Hit!" : "Miss!",
Colour = result.IsHit ? Color4.Green : Color4.Red,
Font = OsuFont.GetFont(size: 30),
2018-04-13 17:19:50 +08:00
Position = osuObject.HitObject.StackedEndPosition + judgementOffsetDirection * new Vector2(0, 45)
});
text.Delay(150)
.Then().FadeOut(200)
.Then().Expire();
judgementOffsetDirection *= -1;
}
}
}