1
0
mirror of https://github.com/ppy/osu.git synced 2024-12-18 05:43:21 +08:00
osu-lazer/osu.Game.Rulesets.Osu/Skinning/Legacy/LegacySpinner.cs

226 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.
2020-11-05 17:12:13 +08:00
using System;
using System.Globalization;
using osu.Framework.Allocation;
using osu.Framework.Bindables;
using osu.Framework.Extensions.ObjectExtensions;
using osu.Framework.Graphics;
using osu.Framework.Graphics.Containers;
2020-11-05 17:12:13 +08:00
using osu.Framework.Graphics.Sprites;
using osu.Game.Rulesets.Objects.Drawables;
using osu.Game.Rulesets.Osu.Objects.Drawables;
2020-11-05 17:12:13 +08:00
using osu.Game.Skinning;
using osuTK;
2020-12-04 19:21:53 +08:00
namespace osu.Game.Rulesets.Osu.Skinning.Legacy
{
2022-11-24 13:32:20 +08:00
public abstract partial class LegacySpinner : CompositeDrawable, IHasApproachCircle
{
public const float SPRITE_SCALE = 0.625f;
/// <remarks>
2021-03-11 20:21:44 +08:00
/// All constants are in osu!stable's gamefield space, which is shifted 16px downwards.
/// This offset is negated to bring all constants into window-space.
2021-03-11 19:57:00 +08:00
/// Note: SPINNER_Y_CENTRE + SPINNER_TOP_OFFSET - Position.Y = 240 (=480/2, or half the window-space in osu!stable)
/// </remarks>
2021-03-11 19:57:00 +08:00
protected const float SPINNER_TOP_OFFSET = 45f - 16f;
2021-03-11 19:57:00 +08:00
protected const float SPINNER_Y_CENTRE = SPINNER_TOP_OFFSET + 219f;
2021-03-26 18:10:04 +08:00
private const float spm_hide_offset = 50f;
protected DrawableSpinner DrawableSpinner { get; private set; } = null!;
public Drawable? ApproachCircle { get; protected set; }
private Sprite spin = null!;
private Sprite clear = null!;
2020-11-05 17:12:13 +08:00
private LegacySpriteText bonusCounter = null!;
private Sprite spmBackground = null!;
private LegacySpriteText spmCounter = null!;
2021-03-26 18:10:04 +08:00
[BackgroundDependencyLoader]
2020-11-05 17:12:13 +08:00
private void load(DrawableHitObject drawableHitObject, ISkinSource source)
{
Anchor = Anchor.Centre;
Origin = Anchor.Centre;
2021-03-11 20:21:44 +08:00
// osu!stable positions spinner components in window-space (as opposed to gamefield-space). This is a 640x480 area taking up the entire screen.
// In lazer, the gamefield-space positional transformation is applied in OsuPlayfieldAdjustmentContainer, which is inverted here to make this area take up the entire window space.
Size = new Vector2(640, 480);
Position = new Vector2(0, -8f);
DrawableSpinner = (DrawableSpinner)drawableHitObject;
2020-11-05 17:12:13 +08:00
AddInternal(new Container
2020-11-05 17:12:13 +08:00
{
Depth = float.MinValue,
RelativeSizeAxes = Axes.Both,
Children = new Drawable[]
{
spin = new Sprite
{
Alpha = 0,
Anchor = Anchor.TopCentre,
Origin = Anchor.Centre,
Texture = source.GetTexture("spinner-spin"),
Scale = new Vector2(SPRITE_SCALE),
Y = SPINNER_TOP_OFFSET + 335,
},
clear = new Sprite
{
Alpha = 0,
Anchor = Anchor.TopCentre,
Origin = Anchor.Centre,
Texture = source.GetTexture("spinner-clear"),
Scale = new Vector2(SPRITE_SCALE),
Y = SPINNER_TOP_OFFSET + 115,
},
bonusCounter = new LegacySpriteText(LegacyFont.Score)
{
Alpha = 0,
Anchor = Anchor.TopCentre,
Origin = Anchor.Centre,
Scale = new Vector2(SPRITE_SCALE),
Y = SPINNER_TOP_OFFSET + 299,
},
2021-03-26 18:10:04 +08:00
spmBackground = new Sprite
{
Anchor = Anchor.TopCentre,
Origin = Anchor.TopLeft,
Texture = source.GetTexture("spinner-rpm"),
Scale = new Vector2(SPRITE_SCALE),
Position = new Vector2(-87, 445 + spm_hide_offset),
},
spmCounter = new LegacySpriteText(LegacyFont.Score)
2021-03-26 18:10:04 +08:00
{
Anchor = Anchor.TopCentre,
Origin = Anchor.TopRight,
Scale = new Vector2(SPRITE_SCALE * 0.9f),
Position = new Vector2(80, 448 + spm_hide_offset),
},
}
2020-11-05 17:12:13 +08:00
});
}
private IBindable<int> completedSpins = null!;
private IBindable<double> spinsPerMinute = null!;
private readonly Bindable<bool> completed = new Bindable<bool>();
protected override void LoadComplete()
{
base.LoadComplete();
completedSpins = DrawableSpinner.CompletedFullSpins.GetBoundCopy();
completedSpins.BindValueChanged(bonus =>
{
if (DrawableSpinner.CurrentBonusScore <= 0)
return;
bonusCounter.Text = DrawableSpinner.CurrentBonusScore.ToString(NumberFormatInfo.InvariantInfo);
if (DrawableSpinner.CurrentBonusScore == DrawableSpinner.MaximumBonusScore)
{
bonusCounter.ScaleTo(1.4f).Then().ScaleTo(1.8f, 1000, Easing.Out);
bonusCounter.FadeOutFromOne(500, Easing.Out);
}
else
{
bonusCounter.FadeOutFromOne(800, Easing.Out);
bonusCounter.ScaleTo(SPRITE_SCALE * 2f).Then().ScaleTo(SPRITE_SCALE * 1.28f, 800, Easing.Out);
}
});
2021-03-26 18:10:04 +08:00
spinsPerMinute = DrawableSpinner.SpinsPerMinute.GetBoundCopy();
spinsPerMinute.BindValueChanged(spm =>
{
spmCounter.Text = Math.Truncate(spm.NewValue).ToString(@"#0");
}, true);
completed.BindValueChanged(onCompletedChanged, true);
DrawableSpinner.ApplyCustomUpdateState += UpdateStateTransforms;
UpdateStateTransforms(DrawableSpinner, DrawableSpinner.State.Value);
}
private void onCompletedChanged(ValueChangedEvent<bool> completed)
{
if (completed.NewValue)
{
2020-11-05 18:44:34 +08:00
double startTime = Math.Min(Time.Current, DrawableSpinner.HitStateUpdateTime - 400);
2021-07-05 23:52:39 +08:00
using (BeginAbsoluteSequence(startTime))
2020-11-05 18:44:34 +08:00
{
clear.FadeInFromZero(400, Easing.Out);
clear.ScaleTo(SPRITE_SCALE * 2)
.Then().ScaleTo(SPRITE_SCALE * 0.8f, 240, Easing.Out)
.Then().ScaleTo(SPRITE_SCALE, 160);
}
const double fade_out_duration = 50;
2021-07-05 23:52:39 +08:00
using (BeginAbsoluteSequence(DrawableSpinner.HitStateUpdateTime - fade_out_duration))
clear.FadeOut(fade_out_duration);
}
else
{
clear.ClearTransforms();
clear.Alpha = 0;
}
}
protected override void Update()
{
base.Update();
completed.Value = Time.Current >= DrawableSpinner.Result.TimeCompleted;
}
protected virtual void UpdateStateTransforms(DrawableHitObject drawableHitObject, ArmedState state)
{
2020-11-05 17:12:13 +08:00
switch (drawableHitObject)
{
case DrawableSpinner d:
2021-03-26 18:10:04 +08:00
using (BeginAbsoluteSequence(d.HitObject.StartTime - d.HitObject.TimeFadeIn))
{
spmBackground.MoveToOffset(new Vector2(0, -spm_hide_offset), d.HitObject.TimeFadeIn, Easing.Out);
spmCounter.MoveToOffset(new Vector2(0, -spm_hide_offset), d.HitObject.TimeFadeIn, Easing.Out);
}
using (BeginAbsoluteSequence(d.HitObject.StartTime - d.HitObject.TimeFadeIn / 2))
spin.FadeInFromZero(d.HitObject.TimeFadeIn / 2);
using (BeginAbsoluteSequence(d.HitObject.StartTime))
ApproachCircle?.ScaleTo(SPRITE_SCALE * 0.1f, d.HitObject.Duration);
2021-03-26 18:10:04 +08:00
double spinFadeOutLength = Math.Min(400, d.HitObject.Duration);
2020-11-05 17:12:13 +08:00
2021-07-05 23:52:39 +08:00
using (BeginAbsoluteSequence(drawableHitObject.HitStateUpdateTime - spinFadeOutLength))
2021-03-26 18:10:04 +08:00
spin.FadeOutFromOne(spinFadeOutLength);
2020-11-05 17:12:13 +08:00
break;
case DrawableSpinnerTick d:
if (state == ArmedState.Hit)
{
2021-07-05 23:52:39 +08:00
using (BeginAbsoluteSequence(d.HitStateUpdateTime))
2020-11-05 17:12:13 +08:00
spin.FadeOut(300);
}
break;
}
}
protected override void Dispose(bool isDisposing)
{
base.Dispose(isDisposing);
if (DrawableSpinner.IsNotNull())
DrawableSpinner.ApplyCustomUpdateState -= UpdateStateTransforms;
}
}
}