Merge remote-tracking branch 'refs/remotes/upstream/master' into hit-samples

osu.Game.Modes.Osu/UI/OsuComboCounter.cs

@@ -0,0 +1,142 @@
+//Copyright (c) 2007-2016 ppy Pty Ltd <contact@ppy.sh>.
+//Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Modes.UI;
+using OpenTK;
+using osu.Framework.Graphics.Primitives;
+
+namespace osu.Game.Modes.Osu.UI
+{
+    /// <summary>
+    /// Uses the 'x' symbol and has a pop-out effect while rolling over. Used in osu! standard.
+    /// </summary>
+    public class OsuComboCounter : ComboCounter
+    {
+        protected uint ScheduledPopOutCurrentId = 0;
+
+        protected virtual float PopOutSmallScale => 1.1f;
+        protected virtual bool CanPopOutWhileRolling => false;
+
+        public Vector2 PopOutScale = new Vector2(1.6f);
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            PopOutCount.Origin = Origin;
+            PopOutCount.Anchor = Anchor;
+        }
+
+        protected override string FormatCount(ulong count)
+        {
+            return $@"{count}x";
+        }
+
+        protected virtual void TransformPopOut(ulong newValue)
+        {
+            PopOutCount.Text = FormatCount(newValue);
+
+            PopOutCount.ScaleTo(PopOutScale);
+            PopOutCount.FadeTo(PopOutInitialAlpha);
+            PopOutCount.MoveTo(Vector2.Zero);
+
+            PopOutCount.ScaleTo(1, PopOutDuration, PopOutEasing);
+            PopOutCount.FadeOut(PopOutDuration, PopOutEasing);
+            PopOutCount.MoveTo(DisplayedCountSpriteText.Position, PopOutDuration, PopOutEasing);
+        }
+
+        protected virtual void TransformPopOutRolling(ulong newValue)
+        {
+            TransformPopOut(newValue);
+            TransformPopOutSmall(newValue);
+        }
+
+        protected virtual void TransformNoPopOut(ulong newValue)
+        {
+            DisplayedCountSpriteText.Text = FormatCount(newValue);
+            DisplayedCountSpriteText.ScaleTo(1);
+        }
+
+        protected virtual void TransformPopOutSmall(ulong newValue)
+        {
+            DisplayedCountSpriteText.Text = FormatCount(newValue);
+            DisplayedCountSpriteText.ScaleTo(PopOutSmallScale);
+            DisplayedCountSpriteText.ScaleTo(1, PopOutDuration, PopOutEasing);
+        }
+
+        protected virtual void ScheduledPopOutSmall(uint id)
+        {
+            // Too late; scheduled task invalidated
+            if (id != ScheduledPopOutCurrentId)
+                return;
+
+            DisplayedCount++;
+        }
+
+        protected override void OnCountRolling(ulong currentValue, ulong newValue)
+        {
+            ScheduledPopOutCurrentId++;
+
+            // Hides displayed count if was increasing from 0 to 1 but didn't finish
+            if (currentValue == 0 && newValue == 0)
+                DisplayedCountSpriteText.FadeOut(FadeOutDuration);
+
+            base.OnCountRolling(currentValue, newValue);
+        }
+
+        protected override void OnCountIncrement(ulong currentValue, ulong newValue)
+        {
+            ScheduledPopOutCurrentId++;
+
+            if (DisplayedCount < currentValue)
+                DisplayedCount++;
+
+            DisplayedCountSpriteText.Show();
+
+            TransformPopOut(newValue);
+            
+            uint newTaskId = ScheduledPopOutCurrentId;
+            Scheduler.AddDelayed(delegate
+            {
+                ScheduledPopOutSmall(newTaskId);
+            }, PopOutDuration);
+        }
+
+        protected override void OnCountChange(ulong currentValue, ulong newValue)
+        {
+            ScheduledPopOutCurrentId++;
+
+            if (newValue == 0)
+                DisplayedCountSpriteText.FadeOut();
+
+            base.OnCountChange(currentValue, newValue);
+        }
+
+        protected override void OnDisplayedCountRolling(ulong currentValue, ulong newValue)
+        {
+            if (newValue == 0)
+                DisplayedCountSpriteText.FadeOut(FadeOutDuration);
+            else
+                DisplayedCountSpriteText.Show();
+
+            if (CanPopOutWhileRolling)
+                TransformPopOutRolling(newValue);
+            else
+                TransformNoPopOut(newValue);
+        }
+
+        protected override void OnDisplayedCountChange(ulong newValue)
+        {
+            DisplayedCountSpriteText.FadeTo(newValue == 0 ? 0 : 1);
+
+            TransformNoPopOut(newValue);
+        }
+
+        protected override void OnDisplayedCountIncrement(ulong newValue)
+        {
+            DisplayedCountSpriteText.Show();
+
+            TransformPopOutSmall(newValue);
+        }
+    }
+}

osu.Game.Modes.Osu/UI/OsuHitRenderer.cs

@@ -0,0 +1,28 @@
+//Copyright (c) 2007-2016 ppy Pty Ltd <contact@ppy.sh>.
+//Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Modes.Objects;
+using osu.Game.Modes.Objects.Drawables;
+using osu.Game.Modes.Osu.Objects;
+using osu.Game.Modes.Osu.Objects.Drawables;
+using osu.Game.Modes.UI;
+
+namespace osu.Game.Modes.Osu.UI
+{
+    public class OsuHitRenderer : HitRenderer<OsuHitObject>
+    {
+        protected override HitObjectConverter<OsuHitObject> Converter => new OsuHitObjectConverter();
+
+        protected override Playfield CreatePlayfield() => new OsuPlayfield();
+
+        protected override DrawableHitObject GetVisualRepresentation(OsuHitObject h)
+        {
+            if (h is HitCircle)
+                return new DrawableHitCircle(h as HitCircle);
+            if (h is Slider)
+                return new DrawableSlider(h as Slider);
+
+            return null;
+        }
+    }
+}

osu.Game.Modes.Osu/UI/OsuPlayfield.cs

@@ -0,0 +1,73 @@
+//Copyright (c) 2007-2016 ppy Pty Ltd <contact@ppy.sh>.
+//Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Modes.Objects.Drawables;
+using osu.Game.Modes.Osu.Objects;
+using osu.Game.Modes.Osu.Objects.Drawables;
+using osu.Game.Modes.UI;
+using OpenTK;
+
+namespace osu.Game.Modes.Osu.UI
+{
+    public class OsuPlayfield : Playfield
+    {
+        private Container approachCircles;
+        private Container judgementLayer;
+
+        public override Vector2 Size
+        {
+            get
+            {
+                var parentSize = Parent.DrawSize;
+                var aspectSize = parentSize.X * 0.75f < parentSize.Y ? new Vector2(parentSize.X, parentSize.X * 0.75f) : new Vector2(parentSize.Y * 4f / 3f, parentSize.Y);
+
+                return new Vector2(aspectSize.X / parentSize.X, aspectSize.Y / parentSize.Y) * base.Size;
+            }
+        }
+
+        public OsuPlayfield()
+        {
+            Anchor = Anchor.Centre;
+            Origin = Anchor.Centre;
+            RelativeSizeAxes = Axes.Both;
+            Size = new Vector2(0.75f);
+
+            Add(new Drawable[]
+            {
+                judgementLayer = new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Depth = 1,
+                },
+                approachCircles = new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Depth = -1,
+                }
+            });
+        }
+
+        public override void Add(DrawableHitObject h)
+        {
+            h.Depth = (float)h.HitObject.StartTime;
+            DrawableHitCircle c = h as DrawableHitCircle;
+            if (c != null)
+            {
+                approachCircles.Add(c.ApproachCircle.CreateProxy());
+            }
+
+            h.OnJudgement += judgement;
+
+            base.Add(h);
+        }
+
+        private void judgement(DrawableHitObject h, JudgementInfo j)
+        {
+            HitExplosion explosion = new HitExplosion((OsuJudgementInfo)j, (OsuHitObject)h.HitObject);
+
+            judgementLayer.Add(explosion);
+        }
+    }
+}

osu.Game.Modes.Osu/UI/OsuScoreOverlay.cs

@@ -0,0 +1,53 @@
+//Copyright (c) 2007-2016 ppy Pty Ltd <contact@ppy.sh>.
+//Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Graphics;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Modes.UI;
+using OpenTK;
+using OpenTK.Input;
+using osu.Framework.Graphics.Primitives;
+
+namespace osu.Game.Modes.Osu.UI
+{
+    public class OsuScoreOverlay : ScoreOverlay
+    {
+        protected override ScoreCounter CreateScoreCounter() => new ScoreCounter()
+        {
+            Anchor = Anchor.TopRight,
+            Origin = Anchor.TopRight,
+            TextSize = 60,
+            Margin = new MarginPadding { Right = 5 },
+        };
+
+        protected override PercentageCounter CreateAccuracyCounter() => new PercentageCounter()
+        {
+            Anchor = Anchor.TopRight,
+            Origin = Anchor.TopRight,
+            Position = new Vector2(0, 55),
+            Margin = new MarginPadding { Right = 5 },
+        };
+
+        protected override ComboCounter CreateComboCounter() => new OsuComboCounter()
+        {
+            Anchor = Anchor.BottomLeft,
+            Origin = Anchor.BottomLeft,
+        };
+
+        protected override KeyCounterCollection CreateKeyCounter() => new KeyCounterCollection
+        {
+            IsCounting = true,
+            FadeTime = 50,
+            Anchor = Anchor.BottomRight,
+            Origin = Anchor.BottomRight,
+            Margin = new MarginPadding(10),
+            Children = new KeyCounter[]
+            {
+                new KeyCounterKeyboard(@"Z", Key.Z),
+                new KeyCounterKeyboard(@"X", Key.X),
+                new KeyCounterMouse(@"M1", MouseButton.Left),
+                new KeyCounterMouse(@"M2", MouseButton.Right),
+            }
+        };
+    }
+}