Rolling counters (initial)

osu.Game/Graphics/UserInterface/AccuracyCounter.cs

@@ -0,0 +1,102 @@
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Transformations;
+using osu.Framework.MathUtils;
+using osu.Framework.Timing;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace osu.Game.Graphics.UserInterface
+{
+    /// <summary>
+    /// Used as an accuracy counter. Represented visually as a percentage, internally as a fraction.
+    /// </summary>
+    public class AccuracyCounter : RollingCounter<float>
+    {
+        private long numerator = 0;
+        public long Numerator
+        {
+            get
+            {
+                return numerator;
+            }
+            set
+            {
+                numerator = value;
+                updateCount();
+            }
+        }
+
+        private ulong denominator = 0;
+        public ulong Denominator
+        {
+            get
+            {
+                return denominator;
+            }
+            set
+            {
+                denominator = value;
+                updateCount();
+            }
+        }
+
+        public void SetCount(long num, ulong den)
+        {
+            numerator = num;
+            denominator = den;
+            updateCount();
+        }
+
+        private void updateCount()
+        {
+            Count = Denominator == 0 ? 100.0f : (Numerator * 100.0f) / Denominator;
+        }
+
+        public override void ResetCount()
+        {
+            numerator = 0;
+            denominator = 0;
+            updateCount();
+            StopRolling();
+        }
+
+        protected override string formatCount(float count)
+        {
+            return count.ToString("0.00") + "%";
+        }
+
+        protected override void transformCount(float currentValue, float newValue)
+        {
+            transformCount(new TransformAccuracy(Clock), currentValue, newValue);
+        }
+
+        protected class TransformAccuracy : Transform<float>
+        {
+            public override float CurrentValue
+            {
+                get
+                {
+                    double time = Time;
+                    if (time < StartTime) return StartValue;
+                    if (time >= EndTime) return EndValue;
+
+                    return Interpolation.ValueAt(time, StartValue, EndValue, StartTime, EndTime, Easing);
+                }
+            }
+
+            public override void Apply(Drawable d)
+            {
+                base.Apply(d);
+                (d as AccuracyCounter).VisibleCount = CurrentValue;
+            }
+
+            public TransformAccuracy(IClock clock)
+                : base(clock)
+            {
+            }
+        }
+    }
+}

osu.Game/Graphics/UserInterface/AlternativeComboCounter.cs

@@ -0,0 +1,86 @@
+using OpenTK;
+using OpenTK.Graphics;
+using osu.Framework.Graphics.Transformations;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace osu.Game.Graphics.UserInterface
+{
+    /// <summary>
+    /// Allows tint and vertical scaling animation. Used by osu!taiko and osu!mania.
+    /// </summary>
+    public class AlternativeComboCounter : ULongCounter // btw, I'm terribly bad with names... OUENDAN!
+    {
+        public Color4 OriginalColour;
+        public Color4 TintColour = Color4.OrangeRed;
+        public int TintDuration = 500;
+        public float ScaleFactor = 1;
+        public EasingTypes TintEasing = EasingTypes.None;
+        public bool CanAnimateWhenBackwards = false;
+
+        public AlternativeComboCounter()
+        {
+            IsRollingContinuous = false;
+        }
+
+        public override void Load()
+        {
+            base.Load();
+            countSpriteText.Hide();
+            OriginalColour = Colour;
+        }
+
+        public override void ResetCount()
+        {
+            SetCountWithoutRolling(0);
+        }
+
+        protected override void transformCount(ulong currentValue, ulong newValue)
+        {
+            // Animate rollover only when going backwards
+            if (newValue > currentValue)
+            {
+                updateTransforms(typeof(TranformULongCounter));
+                removeTransforms(typeof(TranformULongCounter));
+                VisibleCount = newValue;
+            }
+            else
+                transformCount(new TranformULongCounter(Clock), currentValue, newValue);
+        }
+
+        protected override ulong GetProportionalDuration(ulong currentValue, ulong newValue)
+        {
+            ulong difference = currentValue > newValue ? currentValue - newValue : currentValue - newValue;
+            return difference * RollingDuration;
+        }
+
+        protected virtual void transformAnimate()
+        {
+            countSpriteText.Colour = TintColour;
+            countSpriteText.ScaleTo(new Vector2(1, ScaleFactor));
+            countSpriteText.FadeColour(OriginalColour, TintDuration, TintEasing);
+            countSpriteText.ScaleTo(new Vector2(1, 1), TintDuration, TintEasing);
+        }
+
+        protected override void transformVisibleCount(ulong currentValue, ulong newValue)
+        {
+            if (countSpriteText != null)
+            {
+                countSpriteText.Text = newValue.ToString(@"#,0");
+                if (newValue == 0)
+                {
+                    countSpriteText.FadeOut(TintDuration);
+                    return;
+                }
+                countSpriteText.Show();
+                if (newValue > currentValue || CanAnimateWhenBackwards)
+                {
+                    transformAnimate();
+                }
+            }
+        }
+    }
+}

osu.Game/Graphics/UserInterface/CatchComboCounter.cs

@@ -0,0 +1,56 @@
+using OpenTK.Graphics;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace osu.Game.Graphics.UserInterface
+{
+    /// <summary>
+    /// Similar to Standard, but without the 'x' and has colour shadows. Used by osu!catch.
+    /// </summary>
+    public class CatchComboCounter : StandardComboCounter
+    {
+        public CatchComboCounter()
+        {
+            CanPopOutWhenBackwards = true;
+        }
+
+        protected override string formatCount(ulong count)
+        {
+            return count.ToString("#,0");
+        }
+
+        protected override void transformCount(ulong currentValue, ulong newValue)
+        {
+            // Animate rollover only when going backwards
+            if (newValue > currentValue)
+            {
+                updateTransforms(typeof(TranformULongCounter));
+                removeTransforms(typeof(TranformULongCounter));
+                VisibleCount = newValue;
+            }
+            else
+            {
+                popOutSpriteText.Colour = countSpriteText.Colour;
+                transformCount(new TranformULongCounter(Clock), currentValue, newValue);
+            }
+        }
+
+        /// <summary>
+        /// Tints pop-out before animation. Intended to use the last grabbed fruit colour.
+        /// </summary>
+        /// <param name="colour"></param>
+        public void CatchFruit(Color4 colour)
+        {
+            popOutSpriteText.Colour = colour;
+            Count++;
+        }
+
+        public override void ResetCount()
+        {
+            base.ResetCount();
+        }
+    }
+}

osu.Game/Graphics/UserInterface/RollingCounter.cs

@@ -0,0 +1,239 @@
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.Transformations;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace osu.Game.Graphics.UserInterface
+{
+    /// <summary>
+    /// Skeleton for a counter with a simple rollover animation.
+    /// </summary>
+    /// <typeparam name="T">Type of the actual counter.</typeparam>
+    public abstract class RollingCounter<T> : Container
+    {
+        protected SpriteText countSpriteText;
+        protected ulong RollingTotalDuration = 0;
+
+        protected float textSize = 20.0f;
+        public float TextSize
+        {
+            get { return textSize; }
+            set
+            {
+                textSize = value;
+                updateTextSize();
+            }
+        }
+
+        /// <summary>
+        /// If true, each time the Count is updated, it will roll over from the current visible value.
+        /// Else, it will roll over from the current count value.
+        /// </summary>
+        public bool IsRollingContinuous = true;
+
+        /// <summary>
+        /// If true, the rollover duration will be proportional to the counter.
+        /// </summary>
+        public bool IsRollingProportional = false;
+
+        /// <summary>
+        /// If IsRollingProportional = false, duration in milliseconds for the counter rollover animation for each element.
+        /// If IsRollingProportional = true, duration in milliseconds for the counter rollover animation in total.
+        /// </summary>
+        public ulong RollingDuration = 0;
+
+        /// <summary>
+        /// Easing for the counter rollover animation.
+        /// </summary>
+        public EasingTypes RollingEasing = EasingTypes.None;
+
+        protected T visibleCount;
+
+        /// <summary>
+        /// Value shown at the current moment.
+        /// </summary>
+        public virtual T VisibleCount
+        {
+            get
+            {
+                return visibleCount;
+            }
+            protected set
+            {
+                if (visibleCount.Equals(value))
+                    return;
+                transformVisibleCount(visibleCount, value);
+                visibleCount = value;
+            }
+        }
+
+        protected T count;
+
+        /// <summary>
+        /// Actual value of counter.
+        /// </summary>
+        public virtual T Count
+        {
+            get
+            {
+                return count;
+            }
+            set
+            {
+                if (Clock != null)
+                {
+                    RollingTotalDuration = IsRollingProportional ? GetProportionalDuration(VisibleCount, value) : RollingDuration;
+                    transformCount(IsRollingContinuous ? VisibleCount : count, value);
+                }
+                count = value;
+            }
+        }
+
+        public override void Load()
+        {
+            base.Load();
+            removeTransforms(typeof(Transform<T>));
+            if (Count == null)
+                ResetCount();
+            VisibleCount = Count;
+            Children = new Drawable[]
+            {
+                countSpriteText = new SpriteText
+                {
+                    Text = formatCount(Count),
+                    TextSize = this.TextSize,
+                    Anchor = this.Anchor,
+                    Origin = this.Origin,
+                },
+            };
+        }
+
+        /// <summary>
+        /// Calculates the duration of the rollover animation by using the difference between the current visible value and the new final value.
+        /// </summary>
+        /// <remarks>
+        /// Intended to be used in conjunction with IsRolloverProportional = true.
+        /// If you're sure your superclass won't never need to be proportional, then 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 ulong 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>
+        /// Sets count value, bypassing rollover animation.
+        /// </summary>
+        /// <param name="count">New count value.</param>
+        public virtual void SetCountWithoutRolling(T count)
+        {
+            Count = count;
+            StopRolling();
+        }
+
+        /// <summary>
+        /// Stops rollover animation, forcing the visible count to be the actual count.
+        /// </summary>
+        public virtual void StopRolling()
+        {
+            removeTransforms(typeof(Transform<T>));
+            VisibleCount = Count;
+        }
+
+        /// <summary>
+        /// Resets count to default value.
+        /// </summary>
+        public abstract void ResetCount();
+
+        protected void updateTransforms(Type type)
+        {
+            foreach (ITransform t in Transforms.AliveItems)
+                if (t.GetType().IsAssignableFrom(type))
+                    t.Apply(this);
+        }
+
+        protected void removeTransforms(Type type)
+        {
+            Transforms.RemoveAll(t => t.GetType().IsSubclassOf(type));
+        }
+
+        /// <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>
+        /// <remarks>
+        /// Unless you need to set a custom animation according to the current or new value of the count, the recommended approach is to call
+        /// transformCount(CustomTransformer(Clock), currentValue, newValue), where CustomTransformer is a custom Transformer related to the
+        /// type T of the RolloverCounter.
+        /// By using this approach, there is no need to check if the Clock is not null; this validation is done before adding the transformer.
+        /// </remarks>
+        protected abstract void transformCount(T currentValue, T newValue);
+
+        /// <summary>
+        /// Intended to be used by transformCount().
+        /// </summary>
+        /// <see cref="transformCount"/>
+        protected void transformCount(Transform<T> transform, T currentValue, T newValue)
+        {
+            Type type = transform.GetType();
+
+            updateTransforms(type);
+            removeTransforms(type);
+
+            if (Clock == null)
+                return;
+
+            if (RollingDuration == 0)
+            {
+                VisibleCount = Count;
+                return;
+            }
+
+            transform.StartTime = Time;
+            transform.EndTime = Time + RollingTotalDuration;
+            transform.StartValue = currentValue;
+            transform.EndValue = newValue;
+            transform.Easing = RollingEasing;
+
+            Transforms.Add(transform);
+        }
+
+        /// <summary>
+        /// This procedure is called each time the visible count value is updated.
+        /// Override to create custom animations.
+        /// </summary>
+        /// <param name="currentValue">Visible count value before modification.</param>
+        /// <param name="newValue">Expected visible count value after modification-</param>
+        protected virtual void transformVisibleCount(T currentValue, T newValue)
+        {
+            if (countSpriteText != null)
+            {
+                countSpriteText.Text = formatCount(newValue);
+            }
+        }
+
+        protected virtual void updateTextSize()
+        {
+            if (countSpriteText != null)
+                countSpriteText.TextSize = TextSize;
+        }
+    }
+}

osu.Game/Graphics/UserInterface/ScoreCounter.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace osu.Game.Graphics.UserInterface
+{
+    public class ScoreCounter : ULongCounter
+    {
+        /// <summary>
+        /// How many leading zeroes the counter will have.
+        /// </summary>
+        public uint LeadingZeroes = 0;
+
+        protected override string formatCount(ulong count)
+        {
+            return count.ToString("D" + LeadingZeroes);
+        }
+    }
+}

osu.Game/Graphics/UserInterface/StandardComboCounter.cs

@@ -0,0 +1,110 @@
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.Transformations;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace osu.Game.Graphics.UserInterface
+{
+    /// <summary>
+    /// Uses the 'x' symbol and has a pop-out effect while rolling over. Used by osu! standard.
+    /// </summary>
+    public class StandardComboCounter : ULongCounter
+    {
+        public SpriteText popOutSpriteText;
+
+        public ulong PopOutDuration = 0;
+        public float PopOutBigScale = 2.0f;
+        public float PopOutSmallScale = 1.2f;
+        public EasingTypes PopOutEasing = EasingTypes.None;
+        public bool CanPopOutWhenBackwards = false;
+        public float PopOutInitialAlpha = 1.0f;
+
+        public StandardComboCounter()
+        {
+            IsRollingContinuous = false;
+        }
+
+        public override void Load()
+        {
+            base.Load();
+            countSpriteText.Alpha = 0;
+            Add(popOutSpriteText = new SpriteText
+            {
+                Text = formatCount(Count),
+                Origin = this.Origin,
+                Anchor = this.Anchor,
+                TextSize = this.TextSize,
+                Alpha = 0,
+            });
+        }
+
+        public override void ResetCount()
+        {
+            SetCountWithoutRolling(0);
+        }
+
+        protected override void updateTextSize()
+        {
+            base.updateTextSize();
+            if (popOutSpriteText != null)
+                popOutSpriteText.TextSize = this.TextSize;
+        }
+
+
+        protected override void transformCount(ulong currentValue, ulong newValue)
+        {
+            // Animate rollover only when going backwards
+            if (newValue > currentValue)
+            {
+                updateTransforms(typeof(TranformULongCounter));
+                removeTransforms(typeof(TranformULongCounter));
+                VisibleCount = newValue;
+            }
+            else
+                transformCount(new TranformULongCounter(Clock), currentValue, newValue);
+        }
+
+        protected override ulong GetProportionalDuration(ulong currentValue, ulong newValue)
+        {
+            ulong difference = currentValue > newValue ? currentValue - newValue : currentValue - newValue;
+            return difference * RollingDuration;
+        }
+
+        protected override string formatCount(ulong count)
+        {
+            return count.ToString("#,0") + "x";
+        }
+
+        protected virtual void transformPopOut()
+        {
+            countSpriteText.ScaleTo(PopOutSmallScale);
+            countSpriteText.ScaleTo(1, PopOutDuration, PopOutEasing);
+
+            popOutSpriteText.ScaleTo(PopOutBigScale);
+            popOutSpriteText.FadeTo(PopOutInitialAlpha);
+            popOutSpriteText.ScaleTo(1, PopOutDuration, PopOutEasing);
+            popOutSpriteText.FadeOut(PopOutDuration, PopOutEasing);
+        }
+
+        protected override void transformVisibleCount(ulong currentValue, ulong newValue)
+        {
+            if (countSpriteText != null && popOutSpriteText != null)
+            {
+                countSpriteText.Text = popOutSpriteText.Text = formatCount(newValue);
+                if (newValue == 0)
+                {
+                    countSpriteText.FadeOut(PopOutDuration);
+                }
+                else
+                {
+                    countSpriteText.Show();
+                    if (newValue > currentValue || CanPopOutWhenBackwards)
+                        transformPopOut();
+                }
+            }
+        }
+    }
+}

osu.Game/Graphics/UserInterface/ULongCounter.cs

@@ -0,0 +1,59 @@
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Transformations;
+using osu.Framework.MathUtils;
+using osu.Framework.Timing;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace osu.Game.Graphics.UserInterface
+{
+    /// <summary>
+    /// A simple rollover counter that accepts unsigned long values.
+    /// </summary>
+    public class ULongCounter : RollingCounter<ulong>
+    {
+        protected override void transformCount(ulong currentValue, ulong newValue)
+        {
+            transformCount(new TranformULongCounter(Clock), currentValue, newValue);
+        }
+
+        public override void ResetCount()
+        {
+            SetCountWithoutRolling(0);
+        }
+
+        protected override string formatCount(ulong count)
+        {
+            return count.ToString("#,0");
+        }
+
+        protected class TranformULongCounter : Transform<ulong>
+        {
+            public override ulong CurrentValue
+            {
+                get
+                {
+                    double time = Time;
+                    if (time < StartTime) return StartValue;
+                    if (time >= EndTime) return EndValue;
+
+                    return (ulong)Interpolation.ValueAt(time, StartValue, EndValue, StartTime, EndTime, Easing);
+                }
+            }
+
+            public override void Apply(Drawable d)
+            {
+                base.Apply(d);
+                (d as ULongCounter).VisibleCount = CurrentValue;
+            }
+
+            public TranformULongCounter(IClock clock)
+                : base(clock)
+            {
+            }
+        }
+    }
+}