1
0
mirror of https://github.com/ppy/osu.git synced 2024-11-18 03:52:55 +08:00
osu-lazer/osu.Game/Graphics/UserInterface/RollingCounter.cs

168 lines
5.5 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 osu.Framework.Graphics;
using osu.Framework.Graphics.Containers;
using osu.Framework.Graphics.Sprites;
using osu.Game.Graphics.Sprites;
using System;
using System.Collections.Generic;
using osu.Framework.Allocation;
2019-02-21 18:04:31 +08:00
using osu.Framework.Bindables;
using osu.Framework.Graphics.UserInterface;
2018-04-13 17:19:50 +08:00
namespace osu.Game.Graphics.UserInterface
{
public abstract class RollingCounter<T> : Container, IHasCurrentValue<T>
2018-04-13 17:19:50 +08:00
where T : struct, IEquatable<T>
{
private readonly BindableWithCurrent<T> current = new BindableWithCurrent<T>();
public Bindable<T> Current
{
get => current.Current;
set => current.Current = value;
}
2018-04-13 17:19:50 +08:00
private SpriteText displayedCountSpriteText;
2018-04-13 17:19:50 +08:00
/// <summary>
/// If true, the roll-up duration will be proportional to change in value.
/// </summary>
protected virtual bool IsRollingProportional => false;
/// <summary>
/// If IsRollingProportional = false, duration in milliseconds for the counter roll-up animation for each
/// element; else duration in milliseconds for the counter roll-up animation in total.
/// </summary>
protected virtual double RollingDuration => 0;
/// <summary>
/// Easing for the counter rollover animation.
/// </summary>
protected virtual Easing RollingEasing => Easing.OutQuint;
private T displayedCount;
/// <summary>
/// Value shown at the current moment.
/// </summary>
public virtual T DisplayedCount
{
get => displayedCount;
2018-04-13 17:19:50 +08:00
set
{
if (EqualityComparer<T>.Default.Equals(displayedCount, value))
return;
2019-02-28 12:31:40 +08:00
2018-04-13 17:19:50 +08:00
displayedCount = value;
UpdateDisplay();
2018-04-13 17:19:50 +08:00
}
}
/// <summary>
/// Skeleton of a numeric counter which value rolls over time.
/// </summary>
protected RollingCounter()
{
AutoSizeAxes = Axes.Both;
}
[BackgroundDependencyLoader]
private void load()
2018-04-13 17:19:50 +08:00
{
displayedCountSpriteText = CreateSpriteText();
UpdateDisplay();
Child = displayedCountSpriteText;
2018-04-13 17:19:50 +08:00
}
protected void UpdateDisplay()
{
if (displayedCountSpriteText != null)
displayedCountSpriteText.Text = FormatCount(DisplayedCount);
}
protected override void LoadComplete()
{
base.LoadComplete();
Current.BindValueChanged(val => TransformCount(DisplayedCount, val.NewValue), true);
}
2018-04-13 17:19:50 +08:00
/// <summary>
/// Sets count value, bypassing rollover animation.
/// </summary>
/// <param name="count">New count value.</param>
public virtual void SetCountWithoutRolling(T count)
{
Current.Value = count;
StopRolling();
}
/// <summary>
/// Stops rollover animation, forcing the displayed count to be the actual count.
/// </summary>
public virtual void StopRolling()
{
FinishTransforms(false, nameof(DisplayedCount));
2019-02-21 17:56:34 +08:00
DisplayedCount = Current.Value;
2018-04-13 17:19:50 +08:00
}
/// <summary>
/// Resets count to default value.
/// </summary>
public virtual void ResetCount()
{
2018-10-16 10:40:51 +08:00
SetCountWithoutRolling(default);
2018-04-13 17:19:50 +08:00
}
/// <summary>
/// Calculates the duration of the roll-up animation by using the difference between the current visible value
/// and the new final value.
/// </summary>
/// <remarks>
/// To be used in conjunction with IsRollingProportional = true.
/// Unless a derived class needs to have a proportional rolling, it is not necessary to override this function.
/// </remarks>
/// <param name="currentValue">Current visible value.</param>
/// <param name="newValue">New final value.</param>
/// <returns>Calculated rollover duration in milliseconds.</returns>
protected virtual double GetProportionalDuration(T currentValue, T newValue)
{
return RollingDuration;
}
/// <summary>
/// Used to format counts.
/// </summary>
/// <param name="count">Count to format.</param>
/// <returns>Count formatted as a string.</returns>
protected virtual string FormatCount(T count)
{
return count.ToString();
}
/// <summary>
/// Called when the count is updated to add a transformer that changes the value of the visible count (i.e.
/// implement the rollover animation).
/// </summary>
/// <param name="currentValue">Count value before modification.</param>
/// <param name="newValue">Expected count value after modification.</param>
protected virtual void TransformCount(T currentValue, T newValue)
{
double rollingTotalDuration =
IsRollingProportional
? GetProportionalDuration(currentValue, newValue)
: RollingDuration;
this.TransformTo(nameof(DisplayedCount), newValue, rollingTotalDuration, RollingEasing);
}
protected virtual OsuSpriteText CreateSpriteText() => new OsuSpriteText
{
Font = OsuFont.Numeric.With(size: 40f),
};
2018-04-13 17:19:50 +08:00
}
}