Merge remote-tracking branch 'origin/master' into taiko_barlines

Conflicts:
	osu.Desktop.VisualTests/Tests/TestCaseTaikoPlayfield.cs
	osu.Game.Modes.Taiko/UI/TaikoHitRenderer.cs
	osu.Game.Modes.Taiko/UI/TaikoPlayfield.cs
	osu.Game.Modes.Taiko/osu.Game.Modes.Taiko.csproj

osu.Game.Modes.Taiko/Objects/CentreHit.cs

@@ -0,0 +1,9 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+namespace osu.Game.Modes.Taiko.Objects
+{
+    public class CentreHit : Hit
+    {
+    }
+}

osu.Game.Modes.Taiko/Objects/Drawable/DrawableCentreHit.cs

@@ -0,0 +1,35 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using OpenTK.Input;
+using osu.Game.Modes.Taiko.Objects.Drawable.Pieces;
+using osu.Game.Graphics;
+using osu.Framework.Allocation;
+
+namespace osu.Game.Modes.Taiko.Objects.Drawable
+{
+    public class DrawableCentreHit : DrawableHit
+    {
+        protected override Key[] HitKeys { get; } = { Key.F, Key.J };
+
+        private readonly CirclePiece circlePiece;
+
+        public DrawableCentreHit(Hit hit)
+            : base(hit)
+        {
+            Add(circlePiece = new CirclePiece
+            {
+                Children = new[]
+                {
+                    new CentreHitSymbolPiece()
+                }
+            });
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            circlePiece.AccentColour = colours.PinkDarker;
+        }
+    }
+}

osu.Game.Modes.Taiko/Objects/Drawable/DrawableDrumRoll.cs

@@ -0,0 +1,57 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Modes.Objects.Drawables;
+using osu.Game.Modes.Taiko.Judgements;
+using System.Linq;
+
+namespace osu.Game.Modes.Taiko.Objects.Drawable
+{
+    public class DrawableDrumRoll : DrawableTaikoHitObject
+    {
+        private readonly DrumRoll drumRoll;
+
+        public DrawableDrumRoll(DrumRoll drumRoll)
+            : base(drumRoll)
+        {
+            this.drumRoll = drumRoll;
+
+            int tickIndex = 0;
+            foreach (var tick in drumRoll.Ticks)
+            {
+                var newTick = new DrawableDrumRollTick(tick)
+                {
+                    Depth = tickIndex,
+                    X = (float)((tick.StartTime - HitObject.StartTime) / drumRoll.Duration)
+                };
+
+                AddNested(newTick);
+
+                tickIndex++;
+            }
+        }
+
+        protected override void UpdateState(ArmedState state)
+        {
+        }
+
+        protected override void CheckJudgement(bool userTriggered)
+        {
+            if (userTriggered)
+                return;
+
+            if (Judgement.TimeOffset < 0)
+                return;
+
+            int countHit = NestedHitObjects.Count(o => o.Judgement.Result == HitResult.Hit);
+
+            if (countHit > drumRoll.RequiredGoodHits)
+            {
+                Judgement.Result = HitResult.Hit;
+                Judgement.TaikoResult = countHit >= drumRoll.RequiredGreatHits ? TaikoHitResult.Great : TaikoHitResult.Good;
+            }
+            else
+                Judgement.Result = HitResult.Miss;
+        }
+    }
+}

osu.Game.Modes.Taiko/Objects/Drawable/DrawableDrumRollTick.cs

@@ -0,0 +1,53 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using OpenTK.Input;
+using osu.Game.Modes.Taiko.Judgements;
+using System;
+using osu.Game.Modes.Objects.Drawables;
+
+namespace osu.Game.Modes.Taiko.Objects.Drawable
+{
+    public class DrawableDrumRollTick : DrawableTaikoHitObject
+    {
+        private readonly DrumRollTick tick;
+
+        public DrawableDrumRollTick(DrumRollTick tick)
+            : base(tick)
+        {
+            this.tick = tick;
+        }
+
+        protected override TaikoJudgement CreateJudgement() => new TaikoDrumRollTickJudgement();
+
+        protected override void CheckJudgement(bool userTriggered)
+        {
+            if (!userTriggered)
+            {
+                if (Judgement.TimeOffset > tick.HitWindow)
+                    Judgement.Result = HitResult.Miss;
+                return;
+            }
+
+            if (Math.Abs(Judgement.TimeOffset) < tick.HitWindow)
+            {
+                Judgement.Result = HitResult.Hit;
+                Judgement.TaikoResult = TaikoHitResult.Great;
+            }
+        }
+
+        protected override void UpdateState(ArmedState state)
+        {
+        }
+
+        protected override void UpdateScrollPosition(double time)
+        {
+            // Drum roll ticks shouldn't move
+        }
+
+        protected override bool HandleKeyPress(Key key)
+        {
+            return Judgement.Result == HitResult.None && UpdateJudgement(true);
+        }
+    }
+}

osu.Game.Modes.Taiko/Objects/Drawable/DrawableHit.cs

@@ -0,0 +1,104 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using OpenTK.Input;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Modes.Objects.Drawables;
+using osu.Game.Modes.Taiko.Judgements;
+using System;
+using System.Linq;
+
+namespace osu.Game.Modes.Taiko.Objects.Drawable
+{
+    public abstract class DrawableHit : DrawableTaikoHitObject
+    {
+        /// <summary>
+        /// A list of keys which can result in hits for this HitObject.
+        /// </summary>
+        protected abstract Key[] HitKeys { get; }
+
+        protected override Container<Framework.Graphics.Drawable> Content => bodyContainer;
+
+        private readonly Hit hit;
+
+        /// <summary>
+        /// Whether the last key pressed is a valid hit key.
+        /// </summary>
+        private bool validKeyPressed;
+
+        private readonly Container bodyContainer;
+
+        protected DrawableHit(Hit hit)
+            : base(hit)
+        {
+            this.hit = hit;
+
+            AddInternal(bodyContainer = new Container
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+            });
+        }
+
+        protected override void CheckJudgement(bool userTriggered)
+        {
+            if (!userTriggered)
+            {
+                if (Judgement.TimeOffset > hit.HitWindowGood)
+                    Judgement.Result = HitResult.Miss;
+                return;
+            }
+
+            double hitOffset = Math.Abs(Judgement.TimeOffset);
+
+            if (hitOffset > hit.HitWindowMiss)
+                return;
+
+            if (!validKeyPressed)
+                Judgement.Result = HitResult.Miss;
+            else if (hitOffset < hit.HitWindowGood)
+            {
+                Judgement.Result = HitResult.Hit;
+                Judgement.TaikoResult = hitOffset < hit.HitWindowGreat ? TaikoHitResult.Great : TaikoHitResult.Good;
+            }
+            else
+                Judgement.Result = HitResult.Miss;
+        }
+
+        protected override bool HandleKeyPress(Key key)
+        {
+            if (Judgement.Result != HitResult.None)
+                return false;
+
+            validKeyPressed = HitKeys.Contains(key);
+
+            return UpdateJudgement(true);
+        }
+
+        protected override void UpdateState(ArmedState state)
+        {
+            Delay(HitObject.StartTime - Time.Current + Judgement.TimeOffset, true);
+
+            switch (State)
+            {
+                case ArmedState.Idle:
+                    Delay(hit.HitWindowMiss);
+                    break;
+                case ArmedState.Miss:
+                    FadeOut(100);
+                    break;
+                case ArmedState.Hit:
+                    bodyContainer.ScaleTo(0.8f, 400, EasingTypes.OutQuad);
+                    bodyContainer.MoveToY(-200, 250, EasingTypes.Out);
+                    bodyContainer.Delay(250);
+                    bodyContainer.MoveToY(0, 500, EasingTypes.In);
+
+                    FadeOut(600);
+                    break;
+            }
+
+            Expire();
+        }
+    }
+}

osu.Game.Modes.Taiko/Objects/Drawable/DrawableRimHit.cs

@@ -0,0 +1,35 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Allocation;
+using osu.Game.Graphics;
+using OpenTK.Input;
+using osu.Game.Modes.Taiko.Objects.Drawable.Pieces;
+
+namespace osu.Game.Modes.Taiko.Objects.Drawable
+{
+    public class DrawableRimHit : DrawableHit
+    {
+        protected override Key[] HitKeys { get; } = { Key.D, Key.K };
+
+        private readonly CirclePiece circlePiece;
+
+        public DrawableRimHit(Hit hit)
+            : base(hit)
+        {
+            Add(circlePiece = new CirclePiece
+            {
+                Children = new[]
+                {
+                    new RimHitSymbolPiece()
+                }
+            });
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            circlePiece.AccentColour = colours.BlueDarker;
+        }
+    }
+}

osu.Game.Modes.Taiko/Objects/Drawable/DrawableStrongCentreHit.cs

@@ -0,0 +1,35 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using OpenTK.Input;
+using osu.Game.Modes.Taiko.Objects.Drawable.Pieces;
+using osu.Framework.Allocation;
+using osu.Game.Graphics;
+
+namespace osu.Game.Modes.Taiko.Objects.Drawable
+{
+    public class DrawableStrongCentreHit : DrawableStrongHit
+    {
+        protected override Key[] HitKeys { get; } = { Key.F, Key.J };
+
+        private readonly CirclePiece circlePiece;
+
+        public DrawableStrongCentreHit(Hit hit)
+            : base(hit)
+        {
+            Add(circlePiece = new StrongCirclePiece
+            {
+                Children = new []
+                {
+                    new CentreHitSymbolPiece()
+                }
+            });
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            circlePiece.AccentColour = colours.PinkDarker;
+        }
+    }
+}

osu.Game.Modes.Taiko/Objects/Drawable/DrawableStrongHit.cs

@@ -0,0 +1,89 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using OpenTK.Input;
+using System;
+using System.Linq;
+using osu.Framework.Input;
+using osu.Game.Modes.Objects.Drawables;
+using osu.Game.Modes.Taiko.Judgements;
+
+namespace osu.Game.Modes.Taiko.Objects.Drawable
+{
+    public abstract class DrawableStrongHit : DrawableHit
+    {
+        /// <summary>
+        /// The lenience for the second key press.
+        /// This does not adjust by map difficulty in ScoreV2 yet.
+        /// </summary>
+        private const double second_hit_window = 30;
+
+        private double firstHitTime;
+        private bool firstKeyHeld;
+        private Key firstHitKey;
+
+        protected DrawableStrongHit(Hit hit)
+            : base(hit)
+        {
+        }
+
+        protected override TaikoJudgement CreateJudgement() => new TaikoStrongHitJudgement();
+
+        protected override void CheckJudgement(bool userTriggered)
+        {
+            if (Judgement.Result == HitResult.None)
+            {
+                base.CheckJudgement(userTriggered);
+                return;
+            }
+
+            if (!userTriggered)
+                return;
+
+            // If we get here, we're assured that the key pressed is the correct secondary key
+
+            if (Math.Abs(firstHitTime - Time.Current) < second_hit_window)
+                Judgement.SecondHit = true;
+        }
+
+        protected override bool HandleKeyPress(Key key)
+        {
+            // Check if we've handled the first key
+            if (Judgement.Result == HitResult.None)
+            {
+                // First key hasn't been handled yet, attempt to handle it
+                bool handled = base.HandleKeyPress(key);
+
+                if (handled)
+                {
+                    firstHitTime = Time.Current;
+                    firstHitKey = key;
+                }
+
+                return handled;
+            }
+
+            // If we've already hit the second key, don't handle this object any further
+            if (Judgement.SecondHit)
+                return false;
+
+            // Don't handle represses of the first key
+            if (firstHitKey == key)
+                return false;
+
+            // Don't handle invalid hit key presses
+            if (!HitKeys.Contains(key))
+                return false;
+
+            // Assume the intention was to hit the strong hit with both keys only if the first key is still being held down
+            return firstKeyHeld && UpdateJudgement(true);
+        }
+
+        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
+        {
+            firstKeyHeld = state.Keyboard.Keys.Contains(firstHitKey);
+
+            return base.OnKeyDown(state, args);
+        }
+    }
+}

osu.Game.Modes.Taiko/Objects/Drawable/DrawableStrongRimHit.cs

@@ -0,0 +1,35 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Allocation;
+using osu.Game.Graphics;
+using OpenTK.Input;
+using osu.Game.Modes.Taiko.Objects.Drawable.Pieces;
+
+namespace osu.Game.Modes.Taiko.Objects.Drawable
+{
+    public class DrawableStrongRimHit : DrawableStrongHit
+    {
+        protected override Key[] HitKeys { get; } = { Key.D, Key.K };
+
+        private readonly CirclePiece circlePiece;
+
+        public DrawableStrongRimHit(Hit hit)
+            : base(hit)
+        {
+            Add(circlePiece = new StrongCirclePiece
+            {
+                Children = new[]
+                {
+                    new RimHitSymbolPiece()
+                }
+            });
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            circlePiece.AccentColour = colours.BlueDarker;
+        }
+    }
+}

osu.Game.Modes.Taiko/Objects/Drawable/DrawableSwell.cs

@@ -0,0 +1,242 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using OpenTK;
+using OpenTK.Graphics;
+using OpenTK.Input;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Graphics;
+using osu.Game.Modes.Objects.Drawables;
+using osu.Game.Modes.Taiko.Judgements;
+using osu.Game.Modes.Taiko.Objects.Drawable.Pieces;
+using System;
+using System.Linq;
+
+namespace osu.Game.Modes.Taiko.Objects.Drawable
+{
+    public class DrawableSwell : DrawableTaikoHitObject
+    {
+        /// <summary>
+        /// Invoked when the swell has reached the hit target, i.e. when CurrentTime >= StartTime.
+        /// This is only ever invoked once.
+        /// </summary>
+        public event Action OnStart;
+
+        private const float target_ring_thick_border = 1.4f;
+        private const float target_ring_thin_border = 1f;
+        private const float target_ring_scale = 5f;
+        private const float inner_ring_alpha = 0.65f;
+
+        private readonly Swell swell;
+
+        private readonly Container bodyContainer;
+        private readonly CircularContainer targetRing;
+        private readonly CircularContainer expandingRing;
+
+        private readonly CirclePiece circlePiece;
+
+        private readonly Key[] rimKeys = { Key.D, Key.K };
+        private readonly Key[] centreKeys = { Key.F, Key.J };
+        private Key[] lastKeySet;
+
+        /// <summary>
+        /// The amount of times the user has hit this swell.
+        /// </summary>
+        private int userHits;
+
+        private bool hasStarted;
+        private readonly SwellSymbolPiece symbol;
+
+        public DrawableSwell(Swell swell)
+            : base(swell)
+        {
+            this.swell = swell;
+
+            Children = new Framework.Graphics.Drawable[]
+            {
+                bodyContainer = new Container
+                {
+                    Children = new Framework.Graphics.Drawable[]
+                    {
+                        expandingRing = new CircularContainer
+                        {
+                            Name = "Expanding ring",
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            Alpha = 0,
+                            Size = new Vector2(TaikoHitObject.CIRCLE_RADIUS * 2),
+                            BlendingMode = BlendingMode.Additive,
+                            Masking = true,
+                            Children = new []
+                            {
+                                new Box
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Alpha = inner_ring_alpha,
+                                }
+                            }
+                        },
+                        targetRing = new CircularContainer
+                        {
+                            Name = "Target ring (thick border)",
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            Size = new Vector2(TaikoHitObject.CIRCLE_RADIUS * 2),
+                            Masking = true,
+                            BorderThickness = target_ring_thick_border,
+                            BlendingMode = BlendingMode.Additive,
+                            Children = new Framework.Graphics.Drawable[]
+                            {
+                                new Box
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Alpha = 0,
+                                    AlwaysPresent = true
+                                },
+                                new CircularContainer
+                                {
+                                    Name = "Target ring (thin border)",
+                                    Anchor = Anchor.Centre,
+                                    Origin = Anchor.Centre,
+                                    RelativeSizeAxes = Axes.Both,
+                                    Masking = true,
+                                    BorderThickness = target_ring_thin_border,
+                                    BorderColour = Color4.White,
+                                    Children = new[]
+                                    {
+                                        new Box
+                                        {
+                                            RelativeSizeAxes = Axes.Both,
+                                            Alpha = 0,
+                                            AlwaysPresent = true
+                                        }
+                                    }
+                                }
+                            }
+                        },
+                        circlePiece = new CirclePiece
+                        {
+                            Children = new []
+                            {
+                                symbol = new SwellSymbolPiece()
+                            }
+                        }
+                    }
+                }
+            };
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            circlePiece.AccentColour = colours.YellowDark;
+            expandingRing.Colour = colours.YellowLight;
+            targetRing.BorderColour = colours.YellowDark.Opacity(0.25f);
+        }
+
+        protected override void CheckJudgement(bool userTriggered)
+        {
+            if (userTriggered)
+            {
+                userHits++;
+
+                var completion = (float)userHits / swell.RequiredHits;
+
+                expandingRing.FadeTo(expandingRing.Alpha + MathHelper.Clamp(completion / 16, 0.1f, 0.6f), 50);
+                expandingRing.Delay(50);
+                expandingRing.FadeTo(completion / 8, 2000, EasingTypes.OutQuint);
+                expandingRing.DelayReset();
+
+                symbol.RotateTo((float)(completion * swell.Duration / 8), 4000, EasingTypes.OutQuint);
+
+                expandingRing.ScaleTo(1f + Math.Min(target_ring_scale - 1f, (target_ring_scale - 1f) * completion * 1.3f), 260, EasingTypes.OutQuint);
+
+                if (userHits == swell.RequiredHits)
+                {
+                    Judgement.Result = HitResult.Hit;
+                    Judgement.TaikoResult = TaikoHitResult.Great;
+                }
+            }
+            else
+            {
+                if (Judgement.TimeOffset < 0)
+                    return;
+
+                //TODO: THIS IS SHIT AND CAN'T EXIST POST-TAIKO WORLD CUP
+                if (userHits > swell.RequiredHits / 2)
+                {
+                    Judgement.Result = HitResult.Hit;
+                    Judgement.TaikoResult = TaikoHitResult.Good;
+                }
+                else
+                    Judgement.Result = HitResult.Miss;
+            }
+        }
+
+        protected override void UpdateState(ArmedState state)
+        {
+            const float preempt = 100;
+
+            Delay(HitObject.StartTime - Time.Current - preempt, true);
+
+            targetRing.ScaleTo(target_ring_scale, preempt * 4, EasingTypes.OutQuint);
+
+            Delay(preempt, true);
+
+            Delay(Judgement.TimeOffset + swell.Duration, true);
+
+            const float out_transition_time = 300;
+
+            switch (state)
+            {
+                case ArmedState.Hit:
+                    bodyContainer.ScaleTo(1.4f, out_transition_time);
+                    break;
+            }
+
+            FadeOut(out_transition_time, EasingTypes.Out);
+
+            Expire();
+        }
+
+        protected override void UpdateScrollPosition(double time)
+        {
+            // Make the swell stop at the hit target
+            double t = Math.Min(HitObject.StartTime, time);
+
+            if (t == HitObject.StartTime && !hasStarted)
+            {
+                OnStart?.Invoke();
+                hasStarted = true;
+            }
+
+            base.UpdateScrollPosition(t);
+        }
+
+        protected override bool HandleKeyPress(Key key)
+        {
+            if (Judgement.Result != HitResult.None)
+                return false;
+
+            // Don't handle keys before the swell starts
+            if (Time.Current < HitObject.StartTime)
+                return false;
+
+            // Find the keyset which this key corresponds to
+            var keySet = rimKeys.Contains(key) ? rimKeys : centreKeys;
+
+            // Ensure alternating keysets
+            if (keySet == lastKeySet)
+                return false;
+            lastKeySet = keySet;
+
+            UpdateJudgement(true);
+
+            return true;
+        }
+    }
+}

osu.Game.Modes.Taiko/Objects/Drawable/DrawableTaikoHit.cs

@@ -1,39 +0,0 @@
-// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using osu.Framework.Allocation;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Sprites;
-using osu.Framework.Graphics.Textures;
-using osu.Framework.Graphics.Transforms;
-using OpenTK;
-
-namespace osu.Game.Modes.Taiko.Objects.Drawable
-{
-    internal class DrawableTaikoHit : Sprite
-    {
-        private TaikoHitObject h;
-
-        public DrawableTaikoHit(TaikoHitObject h)
-        {
-            this.h = h;
-
-            Origin = Anchor.Centre;
-            Scale = new Vector2(0.2f);
-            RelativePositionAxes = Axes.Both;
-            Position = new Vector2(1.1f, 0.5f);
-        }
-
-        [BackgroundDependencyLoader]
-        private void load(TextureStore textures)
-        {
-            Texture = textures.Get(@"Menu/logo");
-
-            double duration = 0;
-
-            Transforms.Add(new TransformPositionX { StartTime = h.StartTime - 200, EndTime = h.StartTime, StartValue = 1.1f, EndValue = 0.1f });
-            Transforms.Add(new TransformAlpha { StartTime = h.StartTime + duration + 200, EndTime = h.StartTime + duration + 400, StartValue = 1, EndValue = 0 });
-            Expire(true);
-        }
-    }
-}

osu.Game.Modes.Taiko/Objects/Drawable/DrawableTaikoHitObject.cs

@@ -0,0 +1,70 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using OpenTK.Input;
+using osu.Framework.Graphics;
+using osu.Game.Modes.Objects.Drawables;
+using osu.Game.Modes.Taiko.Judgements;
+using System.Collections.Generic;
+using osu.Framework.Input;
+
+namespace osu.Game.Modes.Taiko.Objects.Drawable
+{
+    public abstract class DrawableTaikoHitObject : DrawableHitObject<TaikoHitObject, TaikoJudgement>
+    {
+        /// <summary>
+        /// A list of keys which this hit object will accept. These are the standard Taiko keys for now.
+        /// These should be moved to bindings later.
+        /// </summary>
+        private readonly List<Key> validKeys = new List<Key>(new[] { Key.D, Key.F, Key.J, Key.K });
+
+        protected DrawableTaikoHitObject(TaikoHitObject hitObject)
+            : base(hitObject)
+        {
+            Anchor = Anchor.CentreLeft;
+            Origin = Anchor.Centre;
+
+            RelativePositionAxes = Axes.X;
+        }
+
+        protected override void LoadComplete()
+        {
+            LifetimeStart = HitObject.StartTime - HitObject.PreEmpt * 2;
+
+            base.LoadComplete();
+        }
+
+        protected override TaikoJudgement CreateJudgement() => new TaikoJudgement();
+
+        /// <summary>
+        /// Sets the scroll position of the DrawableHitObject relative to the offset between
+        /// a time value and the HitObject's StartTime.
+        /// </summary>
+        /// <param name="time"></param>
+        protected virtual void UpdateScrollPosition(double time)
+        {
+            MoveToX((float)((HitObject.StartTime - time) / HitObject.PreEmpt));
+        }
+
+        protected override void Update()
+        {
+            UpdateScrollPosition(Time.Current);
+        }
+
+        protected virtual bool HandleKeyPress(Key key) => false;
+
+        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
+        {
+            // Make sure we don't handle held-down keys
+            if (args.Repeat)
+                return false;
+
+            // Check if we've pressed a valid taiko key
+            if (!validKeys.Contains(args.Key))
+                return false;
+
+            // Handle it!
+            return HandleKeyPress(args.Key);
+        }
+    }
+}

osu.Game.Modes.Taiko/Objects/Drawable/Pieces/CentreHitSymbolPiece.cs

@@ -0,0 +1,31 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Sprites;
+using OpenTK;
+
+namespace osu.Game.Modes.Taiko.Objects.Drawable.Pieces
+{
+    /// <summary>
+    /// The symbol used for centre hit pieces.
+    /// </summary>
+    public class CentreHitSymbolPiece : CircularContainer
+    {
+        public CentreHitSymbolPiece()
+        {
+            Anchor = Anchor.Centre;
+            Origin = Anchor.Centre;
+            Size = new Vector2(CirclePiece.SYMBOL_INNER_SIZE);
+            Masking = true;
+            Children = new[]
+            {
+                new Box
+                {
+                    RelativeSizeAxes = Axes.Both
+                }
+            };
+        }
+    }
+}

osu.Game.Modes.Taiko/Objects/Drawable/Pieces/CirclePiece.cs

@@ -0,0 +1,161 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Graphics.Backgrounds;
+using OpenTK.Graphics;
+using System;
+using osu.Game.Graphics;
+
+namespace osu.Game.Modes.Taiko.Objects.Drawable.Pieces
+{
+    /// <summary>
+    /// A circle piece which is used uniformly through osu!taiko to visualise hitobjects.
+    /// <para>
+    /// The body of this piece will overshoot its parent by <see cref="CirclePiece.Height"/> to form 
+    /// a rounded (_[-Width-]_) figure such that a regular "circle" is the result of a parent with Width = 0.
+    /// </para>
+    /// </summary>
+    public class CirclePiece : Container, IHasAccentColour
+    {
+        public const float SYMBOL_SIZE = TaikoHitObject.CIRCLE_RADIUS * 2f * 0.45f;
+        public const float SYMBOL_BORDER = 8;
+        public const float SYMBOL_INNER_SIZE = SYMBOL_SIZE - 2 * SYMBOL_BORDER;
+
+        private Color4 accentColour;
+        /// <summary>
+        /// The colour of the inner circle and outer glows.
+        /// </summary>
+        public Color4 AccentColour
+        {
+            get { return accentColour; }
+            set
+            {
+                accentColour = value;
+
+                innerBackground.Colour = AccentColour;
+
+                triangles.ColourLight = AccentColour;
+                triangles.ColourDark = AccentColour.Darken(0.1f);
+
+                resetEdgeEffects();
+            }
+        }
+
+        private bool kiaiMode;
+        /// <summary>
+        /// Whether Kiai mode effects are enabled for this circle piece.
+        /// </summary>
+        public bool KiaiMode
+        {
+            get { return kiaiMode; }
+            set
+            {
+                kiaiMode = value;
+
+                resetEdgeEffects();
+            }
+        }
+
+        public override Anchor Origin
+        {
+            get { return Anchor.CentreLeft; }
+            set { throw new InvalidOperationException($"{nameof(CirclePiece)} must always use CentreLeft origin."); }
+        }
+
+        protected override Container<Framework.Graphics.Drawable> Content => SymbolContainer;
+        protected readonly Container SymbolContainer;
+
+        private readonly Container innerLayer;
+        private readonly Container innerCircleContainer;
+        private readonly Box innerBackground;
+        private readonly Triangles triangles;
+
+        public CirclePiece()
+        {
+            RelativeSizeAxes = Axes.X;
+            Height = TaikoHitObject.CIRCLE_RADIUS * 2;
+
+            // The "inner layer" is the body of the CirclePiece that overshoots it by Height/2 px on both sides
+            AddInternal(innerLayer = new Container
+            {
+                Name = "Inner Layer",
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                RelativeSizeAxes = Axes.Y,
+                Children = new Framework.Graphics.Drawable[]
+                {
+                    innerCircleContainer = new CircularContainer
+                    {
+                        Name = "Inner Circle",
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        RelativeSizeAxes = Axes.Both,
+                        Masking = true,
+                        Children = new Framework.Graphics.Drawable[]
+                        {
+                            innerBackground = new Box
+                            {
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                                RelativeSizeAxes = Axes.Both,
+                            },
+                            triangles = new Triangles
+                            {
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                                RelativeSizeAxes = Axes.Both,
+                            }
+                        }
+                    },
+                    new CircularContainer
+                    {
+                        Name = "Ring",
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        RelativeSizeAxes = Axes.Both,
+                        BorderThickness = 8,
+                        BorderColour = Color4.White,
+                        Masking = true,
+                        Children = new[]
+                        {
+                            new Box
+                            {
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                                RelativeSizeAxes = Axes.Both,
+                                Alpha = 0,
+                                AlwaysPresent = true
+                            }
+                        }
+                    },
+                    SymbolContainer = new Container
+                    {
+                        Name = "Symbol",
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                    }
+                }
+            });
+        }
+
+        protected override void Update()
+        {
+            // Add the overshoot to compensate for corner radius
+            innerLayer.Width = DrawWidth + DrawHeight;
+        }
+
+        private void resetEdgeEffects()
+        {
+            innerCircleContainer.EdgeEffect = new EdgeEffect
+            {
+                Type = EdgeEffectType.Glow,
+                Colour = AccentColour,
+                Radius = KiaiMode ? 50 : 8
+            };
+        }
+    }
+}

osu.Game.Modes.Taiko/Objects/Drawable/Pieces/RimHitSymbolPiece.cs

@@ -0,0 +1,36 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Sprites;
+using OpenTK;
+using OpenTK.Graphics;
+
+namespace osu.Game.Modes.Taiko.Objects.Drawable.Pieces
+{
+    /// <summary>
+    /// The symbol used for rim hit pieces.
+    /// </summary>
+    public class RimHitSymbolPiece : CircularContainer
+    {
+        public RimHitSymbolPiece()
+        {
+            Anchor = Anchor.Centre;
+            Origin = Anchor.Centre;
+            Size = new Vector2(CirclePiece.SYMBOL_SIZE);
+            BorderThickness = CirclePiece.SYMBOL_BORDER;
+            BorderColour = Color4.White;
+            Masking = true;
+            Children = new[]
+            {
+                new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Alpha = 0,
+                    AlwaysPresent = true
+                }
+            };
+        }
+    }
+}

osu.Game.Modes.Taiko/Objects/Drawable/Pieces/StrongCirclePiece.cs

@@ -0,0 +1,25 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using OpenTK;
+
+namespace osu.Game.Modes.Taiko.Objects.Drawable.Pieces
+{
+    /// <summary>
+    /// A type of circle piece which is drawn at a higher scale to represent a "strong" piece.
+    /// </summary>
+    public class StrongCirclePiece : CirclePiece
+    {
+        /// <summary>
+        /// The amount to scale up the base circle to show it as a "strong" piece.
+        /// </summary>
+        private const float strong_scale = 1.5f;
+
+        public StrongCirclePiece()
+        {
+            SymbolContainer.Scale = new Vector2(strong_scale);
+        }
+
+        public override Vector2 Size => new Vector2(base.Size.X, base.Size.Y * strong_scale);
+    }
+}

osu.Game.Modes.Taiko/Objects/Drawable/Pieces/SwellSymbolPiece.cs

@@ -0,0 +1,24 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Graphics;
+using osu.Framework.Graphics;
+
+namespace osu.Game.Modes.Taiko.Objects.Drawable.Pieces
+{
+    /// <summary>
+    /// The symbol used for swell pieces.
+    /// </summary>
+    public class SwellSymbolPiece : TextAwesome
+    {
+        public SwellSymbolPiece()
+        {
+            Anchor = Anchor.Centre;
+            Origin = Anchor.Centre;
+            UseFullGlyphHeight = true;
+            TextSize = CirclePiece.SYMBOL_INNER_SIZE;
+            Icon = FontAwesome.fa_asterisk;
+            Shadow = false;
+        }
+    }
+}

osu.Game.Modes.Taiko/Objects/DrumRoll.cs

@@ -0,0 +1,104 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Beatmaps.Samples;
+using osu.Game.Modes.Objects.Types;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using osu.Game.Beatmaps.Timing;
+using osu.Game.Database;
+
+namespace osu.Game.Modes.Taiko.Objects
+{
+    public class DrumRoll : TaikoHitObject, IHasDistance
+    {
+        public double EndTime => StartTime + Distance / Velocity;
+
+        public double Duration => EndTime - StartTime;
+
+        /// <summary>
+        /// Raw length of the drum roll in positional length units.
+        /// </summary>
+        public double Distance { get; set; }
+
+        /// <summary>
+        /// Velocity of the drum roll in positional length units per millisecond.
+        /// </summary>
+        public double Velocity { get; protected set; }
+
+        /// <summary>
+        /// The distance between ticks of this drumroll.
+        /// <para>Half of this value is the hit window of the ticks.</para>
+        /// </summary>
+        public double TickTimeDistance { get; protected set; }
+
+        /// <summary>
+        /// Number of drum roll ticks required for a "Good" hit.
+        /// </summary>
+        public double RequiredGoodHits { get; protected set; }
+
+        /// <summary>
+        /// Number of drum roll ticks required for a "Great" hit.
+        /// </summary>
+        public double RequiredGreatHits { get; protected set; }
+
+        /// <summary>
+        /// Total number of drum roll ticks.
+        /// </summary>
+        public int TotalTicks => Ticks.Count();
+
+        /// <summary>
+        /// Initializes the drum roll ticks if not initialized and returns them.
+        /// </summary>
+        public IEnumerable<DrumRollTick> Ticks => ticks ?? (ticks = createTicks());
+
+        private List<DrumRollTick> ticks;
+
+        public override void ApplyDefaults(TimingInfo timing, BeatmapDifficulty difficulty)
+        {
+            base.ApplyDefaults(timing, difficulty);
+
+            Velocity = timing.SliderVelocityAt(StartTime) * difficulty.SliderMultiplier / 1000;
+            TickTimeDistance = timing.BeatLengthAt(StartTime);
+
+            //TODO: move this to legacy conversion code to allow for direct division without special case.
+            if (difficulty.SliderTickRate == 3)
+                TickTimeDistance /= 3;
+            else
+                TickTimeDistance /= 4;
+
+            RequiredGoodHits = TotalTicks * Math.Min(0.15, 0.05 + 0.10 / 6 * difficulty.OverallDifficulty);
+            RequiredGreatHits = TotalTicks * Math.Min(0.30, 0.10 + 0.20 / 6 * difficulty.OverallDifficulty);
+        }
+
+        private List<DrumRollTick> createTicks()
+        {
+            var ret = new List<DrumRollTick>();
+
+            if (TickTimeDistance == 0)
+                return ret;
+
+            bool first = true;
+            for (double t = StartTime; t < EndTime + (int)TickTimeDistance; t += TickTimeDistance)
+            {
+                ret.Add(new DrumRollTick
+                {
+                    FirstTick = first,
+                    PreEmpt = PreEmpt,
+                    TickTimeDistance = TickTimeDistance,
+                    StartTime = t,
+                    Sample = new HitSampleInfo
+                    {
+                        Type = SampleType.None,
+                        Set = SampleSet.Soft
+                    }
+                });
+
+                first = false;
+            }
+
+            return ret;
+        }
+    }
+}

osu.Game.Modes.Taiko/Objects/DrumRollTick.cs

@@ -0,0 +1,24 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+namespace osu.Game.Modes.Taiko.Objects
+{
+    public class DrumRollTick : TaikoHitObject
+    {
+        /// <summary>
+        /// Whether this is the first (initial) tick of the slider.
+        /// </summary>
+        public bool FirstTick;
+
+        /// <summary>
+        /// The distance between this tick and the next in milliseconds.
+        /// <para>Half of this value is the hit window of the tick.</para>
+        /// </summary>
+        public double TickTimeDistance;
+
+        /// <summary>
+        /// The time allowed to hit this tick.
+        /// </summary>
+        public double HitWindow => TickTimeDistance / 2;
+    }
+}

osu.Game.Modes.Taiko/Objects/Hit.cs

@@ -0,0 +1,35 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Beatmaps.Timing;
+using osu.Game.Database;
+
+namespace osu.Game.Modes.Taiko.Objects
+{
+    public class Hit : TaikoHitObject
+    {
+        /// <summary>
+        /// The hit window that results in a "GREAT" hit.
+        /// </summary>
+        public double HitWindowGreat = 35;
+
+        /// <summary>
+        /// The hit window that results in a "GOOD" hit.
+        /// </summary>
+        public double HitWindowGood = 80;
+
+        /// <summary>
+        /// The hit window that results in a "MISS".
+        /// </summary>
+        public double HitWindowMiss = 95;
+
+        public override void ApplyDefaults(TimingInfo timing, BeatmapDifficulty difficulty)
+        {
+            base.ApplyDefaults(timing, difficulty);
+
+            HitWindowGreat = BeatmapDifficulty.DifficultyRange(difficulty.OverallDifficulty, 50, 35, 20);
+            HitWindowGood = BeatmapDifficulty.DifficultyRange(difficulty.OverallDifficulty, 120, 80, 50);
+            HitWindowMiss = BeatmapDifficulty.DifficultyRange(difficulty.OverallDifficulty, 135, 95, 70);
+        }
+    }
+}

osu.Game.Modes.Taiko/Objects/RimHit.cs

@@ -0,0 +1,9 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+namespace osu.Game.Modes.Taiko.Objects
+{
+    public class RimHit : Hit
+    {
+    }
+}

osu.Game.Modes.Taiko/Objects/Swell.cs

@@ -0,0 +1,30 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using osu.Game.Beatmaps.Timing;
+using osu.Game.Database;
+using osu.Game.Modes.Objects.Types;
+
+namespace osu.Game.Modes.Taiko.Objects
+{
+    public class Swell : TaikoHitObject, IHasEndTime
+    {
+        public double EndTime { get; set; }
+
+        public double Duration => EndTime - StartTime;
+
+        /// <summary>
+        /// The number of hits required to complete the swell successfully.
+        /// </summary>
+        public int RequiredHits { get; protected set; } = 10;
+
+        public override void ApplyDefaults(TimingInfo timing, BeatmapDifficulty difficulty)
+        {
+            base.ApplyDefaults(timing, difficulty);
+
+            double spinnerRotationRatio = BeatmapDifficulty.DifficultyRange(difficulty.OverallDifficulty, 3, 5, 7.5);
+            RequiredHits = (int)Math.Max(1, Duration / 1000f * spinnerRotationRatio);
+        }
+    }
+}

osu.Game.Modes.Taiko/Objects/TaikoHitObject.cs

@@ -7,37 +7,28 @@ using osu.Game.Modes.Objects;
 
 namespace osu.Game.Modes.Taiko.Objects
 {
-    public class TaikoHitObject : HitObject
+    public abstract class TaikoHitObject : HitObject
     {
         /// <summary>
         /// HitCircle radius.
         /// </summary>
-        public const float CIRCLE_RADIUS = 64;
-
-        /// <summary>
-        /// The hit window that results in a "GREAT" hit.
-        /// </summary>
-        public double HitWindowGreat = 35;
-
-        /// <summary>
-        /// The hit window that results in a "GOOD" hit.
-        /// </summary>
-        public double HitWindowGood = 80;
-
-        /// <summary>
-        /// The hit window that results in a "MISS".
-        /// </summary>
-        public double HitWindowMiss = 95;
+        public const float CIRCLE_RADIUS = 42f;
 
         /// <summary>
         /// The time to scroll in the HitObject.
         /// </summary>
         public double PreEmpt;
 
+        /// <summary>
+        /// Whether this HitObject is a "strong" type.
+        /// Strong hit objects give more points for hitting the hit object with both keys.
+        /// </summary>
+        public bool IsStrong;
+
         /// <summary>
         /// Whether this HitObject is in Kiai time.
         /// </summary>
-        public bool Kiai;
+        public bool Kiai { get; protected set; }
 
         public override void ApplyDefaults(TimingInfo timing, BeatmapDifficulty difficulty)
         {
@@ -50,10 +41,6 @@ namespace osu.Game.Modes.Taiko.Objects
 
             if (overridePoint != null)
                 Kiai |= overridePoint.KiaiMode;
-
-            HitWindowGreat = BeatmapDifficulty.DifficultyRange(difficulty.OverallDifficulty, 50, 35, 20);
-            HitWindowGood = BeatmapDifficulty.DifficultyRange(difficulty.OverallDifficulty, 120, 80, 50);
-            HitWindowMiss = BeatmapDifficulty.DifficultyRange(difficulty.OverallDifficulty, 135, 95, 70);
         }
     }
 }