osu/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSlider.cs

236 lines
8.8 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 09:19:50 +00:00
2018-11-20 07:51:59 +00:00
using osuTK;
2018-04-13 09:19:50 +00:00
using osu.Framework.Graphics;
using osu.Game.Rulesets.Objects.Drawables;
using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
using System.Collections.Generic;
using System.Linq;
using osu.Framework.Allocation;
2019-02-21 10:04:31 +00:00
using osu.Framework.Bindables;
2018-04-13 09:19:50 +00:00
using osu.Framework.Graphics.Containers;
2018-11-14 05:29:22 +00:00
using osu.Game.Rulesets.Objects;
2019-01-23 10:46:53 +00:00
using osu.Game.Rulesets.Osu.Configuration;
using osu.Game.Rulesets.Osu.Skinning;
2018-04-13 09:19:50 +00:00
using osu.Game.Rulesets.Scoring;
2018-11-20 07:51:59 +00:00
using osuTK.Graphics;
2018-12-07 21:24:24 +00:00
using osu.Game.Skinning;
2018-04-13 09:19:50 +00:00
namespace osu.Game.Rulesets.Osu.Objects.Drawables
{
public class DrawableSlider : DrawableOsuHitObject, IDrawableHitObjectWithProxiedApproach
{
private readonly Slider slider;
private readonly List<Drawable> components = new List<Drawable>();
public readonly DrawableHitCircle HeadCircle;
public readonly DrawableSliderTail TailCircle;
public readonly SnakingSliderBody Body;
2018-04-13 09:19:50 +00:00
public readonly SliderBall Ball;
2018-11-09 04:58:46 +00:00
private readonly IBindable<Vector2> positionBindable = new Bindable<Vector2>();
private readonly IBindable<float> scaleBindable = new Bindable<float>();
2018-11-14 05:29:22 +00:00
private readonly IBindable<SliderPath> pathBindable = new Bindable<SliderPath>();
2018-11-09 04:58:46 +00:00
[Resolved(CanBeNull = true)]
private OsuRulesetConfigManager config { get; set; }
2018-04-13 09:19:50 +00:00
public DrawableSlider(Slider s)
: base(s)
{
slider = s;
Position = s.StackedPosition;
Container<DrawableSliderTick> ticks;
Container<DrawableRepeatPoint> repeatPoints;
InternalChildren = new Drawable[]
{
Body = new SnakingSliderBody(s),
2018-04-13 09:19:50 +00:00
ticks = new Container<DrawableSliderTick> { RelativeSizeAxes = Axes.Both },
repeatPoints = new Container<DrawableRepeatPoint> { RelativeSizeAxes = Axes.Both },
Ball = new SliderBall(s, this)
2018-04-13 09:19:50 +00:00
{
2019-01-21 01:57:14 +00:00
GetInitialHitAction = () => HeadCircle.HitAction,
2018-04-13 09:19:50 +00:00
BypassAutoSizeAxes = Axes.Both,
Scale = new Vector2(s.Scale),
AlwaysPresent = true,
Alpha = 0
},
HeadCircle = new DrawableSliderHead(s, s.HeadCircle)
{
OnShake = Shake
},
2018-04-13 09:19:50 +00:00
TailCircle = new DrawableSliderTail(s, s.TailCircle)
};
components.Add(Body);
components.Add(Ball);
AddNested(HeadCircle);
AddNested(TailCircle);
components.Add(TailCircle);
foreach (var tick in s.NestedHitObjects.OfType<SliderTick>())
{
var drawableTick = new DrawableSliderTick(tick) { Position = tick.Position - s.Position };
ticks.Add(drawableTick);
components.Add(drawableTick);
AddNested(drawableTick);
}
foreach (var repeatPoint in s.NestedHitObjects.OfType<RepeatPoint>())
{
var drawableRepeatPoint = new DrawableRepeatPoint(repeatPoint, this) { Position = repeatPoint.Position - s.Position };
repeatPoints.Add(drawableRepeatPoint);
components.Add(drawableRepeatPoint);
AddNested(drawableRepeatPoint);
}
2018-11-09 04:58:46 +00:00
}
2018-04-13 09:19:50 +00:00
protected override void UpdateInitialTransforms()
{
base.UpdateInitialTransforms();
Body.FadeInFromZero(HitObject.TimeFadeIn);
}
2018-11-09 04:58:46 +00:00
[BackgroundDependencyLoader]
private void load()
2018-11-09 04:58:46 +00:00
{
config?.BindWith(OsuRulesetSetting.SnakingInSliders, Body.SnakingIn);
config?.BindWith(OsuRulesetSetting.SnakingOutSliders, Body.SnakingOut);
2018-11-09 04:58:46 +00:00
positionBindable.BindValueChanged(_ => Position = HitObject.StackedPosition);
scaleBindable.BindValueChanged(scale =>
2018-10-26 06:33:21 +00:00
{
updatePathRadius();
Ball.Scale = new Vector2(scale.NewValue);
2018-11-09 04:58:46 +00:00
});
2018-11-09 04:58:46 +00:00
positionBindable.BindTo(HitObject.PositionBindable);
scaleBindable.BindTo(HitObject.ScaleBindable);
2018-11-14 05:29:22 +00:00
pathBindable.BindTo(slider.PathBindable);
pathBindable.BindValueChanged(_ => Body.Refresh());
2018-04-13 09:19:50 +00:00
2019-07-22 05:45:25 +00:00
AccentColour.BindValueChanged(colour =>
2018-04-13 09:19:50 +00:00
{
2019-07-22 05:45:25 +00:00
Body.AccentColour = colour.NewValue;
2018-07-02 07:10:56 +00:00
foreach (var drawableHitObject in NestedHitObjects)
2019-07-22 05:45:25 +00:00
drawableHitObject.AccentColour.Value = colour.NewValue;
}, true);
2018-04-13 09:19:50 +00:00
}
public readonly Bindable<bool> Tracking = new Bindable<bool>();
2018-04-13 09:19:50 +00:00
protected override void Update()
{
base.Update();
Tracking.Value = Ball.Tracking;
2018-04-13 09:19:50 +00:00
double completionProgress = MathHelper.Clamp((Time.Current - slider.StartTime) / slider.Duration, 0, 1);
foreach (var c in components.OfType<ISliderProgress>()) c.UpdateProgress(completionProgress);
foreach (var c in components.OfType<ITrackSnaking>()) c.UpdateSnakingPosition(slider.Path.PositionAt(Body.SnakedStart ?? 0), slider.Path.PositionAt(Body.SnakedEnd ?? 0));
2018-04-13 09:19:50 +00:00
foreach (var t in components.OfType<IRequireTracking>()) t.Tracking = Ball.Tracking;
Size = Body.Size;
OriginPosition = Body.PathOffset;
if (DrawSize != Vector2.Zero)
{
var childAnchorPosition = Vector2.Divide(OriginPosition, DrawSize);
foreach (var obj in NestedHitObjects)
obj.RelativeAnchorPosition = childAnchorPosition;
Ball.RelativeAnchorPosition = childAnchorPosition;
}
}
public override void OnKilled()
{
base.OnKilled();
Body.RecyclePath();
}
private float sliderPathRadius;
protected override void ApplySkin(ISkinSource skin, bool allowFallback)
2018-12-07 21:24:24 +00:00
{
base.ApplySkin(skin, allowFallback);
2019-01-07 11:12:39 +00:00
Body.BorderSize = skin.GetConfig<OsuSkinConfiguration, float>(OsuSkinConfiguration.SliderBorderSize)?.Value ?? SliderBody.DEFAULT_BORDER_SIZE;
sliderPathRadius = skin.GetConfig<OsuSkinConfiguration, float>(OsuSkinConfiguration.SliderPathRadius)?.Value ?? OsuHitObject.OBJECT_RADIUS;
updatePathRadius();
Body.AccentColour = skin.GetConfig<OsuSkinColour, Color4>(OsuSkinColour.SliderTrackOverride)?.Value ?? AccentColour.Value;
Body.BorderColour = skin.GetConfig<OsuSkinColour, Color4>(OsuSkinColour.SliderBorder)?.Value ?? Color4.White;
bool allowBallTint = skin.GetConfig<OsuSkinConfiguration, bool>(OsuSkinConfiguration.AllowSliderBallTint)?.Value ?? false;
Ball.Colour = allowBallTint ? AccentColour.Value : Color4.White;
2018-12-07 21:24:24 +00:00
}
private void updatePathRadius() => Body.PathRadius = slider.Scale * sliderPathRadius;
protected override void CheckForResult(bool userTriggered, double timeOffset)
2018-04-13 09:19:50 +00:00
{
if (userTriggered || Time.Current < slider.EndTime)
return;
ApplyResult(r =>
2018-04-13 09:19:50 +00:00
{
2018-07-02 07:10:56 +00:00
var judgementsCount = NestedHitObjects.Count();
2018-04-13 09:19:50 +00:00
var judgementsHit = NestedHitObjects.Count(h => h.IsHit);
var hitFraction = (double)judgementsHit / judgementsCount;
if (hitFraction == 1 && HeadCircle.Result.Type == HitResult.Great)
r.Type = HitResult.Great;
else if (hitFraction >= 0.5 && HeadCircle.Result.Type >= HitResult.Good)
r.Type = HitResult.Good;
2018-04-13 09:19:50 +00:00
else if (hitFraction > 0)
r.Type = HitResult.Meh;
2018-04-13 09:19:50 +00:00
else
r.Type = HitResult.Miss;
});
2018-04-13 09:19:50 +00:00
}
2019-07-22 06:33:12 +00:00
protected override void UpdateStateTransforms(ArmedState state)
2018-04-13 09:19:50 +00:00
{
2019-09-13 09:49:21 +00:00
base.UpdateStateTransforms(state);
2018-04-13 09:19:50 +00:00
Ball.FadeIn();
Ball.ScaleTo(HitObject.Scale);
using (BeginDelayedSequence(slider.Duration, true))
{
const float fade_out_time = 450;
// intentionally pile on an extra FadeOut to make it happen much faster.
Ball.FadeOut(fade_out_time / 4, Easing.Out);
switch (state)
{
case ArmedState.Hit:
Ball.ScaleTo(HitObject.Scale * 1.4f, fade_out_time, Easing.Out);
break;
}
2019-09-12 10:29:08 +00:00
this.FadeOut(fade_out_time, Easing.OutQuint);
2018-04-13 09:19:50 +00:00
}
}
public Drawable ProxiedLayer => HeadCircle.ApproachCircle;
public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => Body.ReceivePositionalInputAt(screenSpacePos);
2018-04-13 09:19:50 +00:00
}
}