Merge pull request #1640 from peppy/catch-hyperdash

osu!catch hyperdash

osu.Game.Rulesets.Catch/Beatmaps/CatchBeatmapProcessor.cs

@@ -1,8 +1,14 @@
 // 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 System.Collections.Generic;
+using System.Linq;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Catch.UI;
+using osu.Game.Rulesets.Objects.Types;
+using OpenTK;
 
 namespace osu.Game.Rulesets.Catch.Beatmaps
 {
@@ -18,6 +24,8 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
 
             CatchHitObject lastObj = null;
 
+            initialiseHyperDash(beatmap.HitObjects);
+
             foreach (var obj in beatmap.HitObjects)
             {
                 if (obj.NewCombo)
@@ -34,5 +42,49 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
                 lastObj = obj;
             }
         }
+
+        private void initialiseHyperDash(List<CatchHitObject> objects)
+        {
+            // todo: add difficulty adjust.
+            double halfCatcherWidth = CatcherArea.CATCHER_SIZE * (objects.FirstOrDefault()?.Scale ?? 1) / CatchPlayfield.BASE_WIDTH / 2;
+
+            int lastDirection = 0;
+            double lastExcess = halfCatcherWidth;
+
+            int objCount = objects.Count;
+
+            for (int i = 0; i < objCount - 1; i++)
+            {
+                CatchHitObject currentObject = objects[i];
+
+                // not needed?
+                // if (currentObject is TinyDroplet) continue;
+
+                CatchHitObject nextObject = objects[i + 1];
+
+                // while (nextObject is TinyDroplet)
+                // {
+                //     if (++i == objCount - 1) break;
+                //     nextObject = objects[i + 1];
+                // }
+
+                int thisDirection = nextObject.X > currentObject.X ? 1 : -1;
+                double timeToNext = nextObject.StartTime - ((currentObject as IHasEndTime)?.EndTime ?? currentObject.StartTime) - 4;
+                double distanceToNext = Math.Abs(nextObject.X - currentObject.X) - (lastDirection == thisDirection ? lastExcess : halfCatcherWidth);
+
+                if (timeToNext * CatcherArea.Catcher.BASE_SPEED < distanceToNext)
+                {
+                    currentObject.HyperDashTarget = nextObject;
+                    lastExcess = halfCatcherWidth;
+                }
+                else
+                {
+                    //currentObject.DistanceToHyperDash = timeToNext - distanceToNext;
+                    lastExcess = MathHelper.Clamp(timeToNext - distanceToNext, 0, halfCatcherWidth);
+                }
+
+                lastDirection = thisDirection;
+            }
+        }
     }
 }

osu.Game.Rulesets.Catch/Objects/CatchHitObject.cs

@@ -27,6 +27,16 @@ namespace osu.Game.Rulesets.Catch.Objects
 
         public float Scale { get; set; } = 1;
 
+        /// <summary>
+        /// Whether this fruit can initiate a hyperdash.
+        /// </summary>
+        public bool HyperDash => HyperDashTarget != null;
+
+        /// <summary>
+        /// The target fruit if we are to initiate a hyperdash.
+        /// </summary>
+        public CatchHitObject HyperDashTarget;
+
         public override void ApplyDefaults(ControlPointInfo controlPointInfo, BeatmapDifficulty difficulty)
         {
             base.ApplyDefaults(controlPointInfo, difficulty);

osu.Game.Rulesets.Catch/Objects/Drawable/DrawableFruit.cs

@@ -7,6 +7,7 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.MathUtils;
 using osu.Game.Rulesets.Catch.Objects.Drawable.Pieces;
 using OpenTK;
+using OpenTK.Graphics;
 
 namespace osu.Game.Rulesets.Catch.Objects.Drawable
 {
@@ -70,6 +71,20 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
                     }
                 }
             };
+
+            if (HitObject.HyperDash)
+            {
+                Add(new Pulp
+                {
+                    RelativePositionAxes = Axes.Both,
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    AccentColour = Color4.Red,
+                    Blending = BlendingMode.Additive,
+                    Alpha = 0.5f,
+                    Scale = new Vector2(2)
+                });
+            }
         }
     }
 }

osu.Game.Rulesets.Catch/Tests/TestCaseCatcherArea.cs

@@ -17,6 +17,7 @@ namespace osu.Game.Rulesets.Catch.Tests
     internal class TestCaseCatcherArea : OsuTestCase
     {
         private RulesetInfo catchRuleset;
+        private TestCatcherArea catcherArea;
 
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {
@@ -26,6 +27,7 @@ namespace osu.Game.Rulesets.Catch.Tests
         public TestCaseCatcherArea()
         {
             AddSliderStep<float>("CircleSize", 0, 8, 5, createCatcher);
+            AddToggleStep("Hyperdash", t => catcherArea.ToggleHyperDash(t));
         }
 
         private void createCatcher(float size)
@@ -33,7 +35,7 @@ namespace osu.Game.Rulesets.Catch.Tests
             Child = new CatchInputManager(catchRuleset)
             {
                 RelativeSizeAxes = Axes.Both,
-                Child = new CatcherArea(new BeatmapDifficulty { CircleSize = size })
+                Child = catcherArea = new TestCatcherArea(new BeatmapDifficulty { CircleSize = size })
                 {
                     Anchor = Anchor.CentreLeft,
                     Origin = Anchor.BottomLeft
@@ -46,5 +48,15 @@ namespace osu.Game.Rulesets.Catch.Tests
         {
             catchRuleset = rulesets.GetRuleset(2);
         }
+
+        private class TestCatcherArea : CatcherArea
+        {
+            public TestCatcherArea(BeatmapDifficulty beatmapDifficulty)
+                : base(beatmapDifficulty)
+            {
+            }
+
+            public void ToggleHyperDash(bool status) => MovableCatcher.HyperDashModifier = status ? 2 : 1;
+        }
     }
 }

osu.Game.Rulesets.Catch/Tests/TestCaseHyperdash.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 NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Catch.Objects;
+
+namespace osu.Game.Rulesets.Catch.Tests
+{
+    [TestFixture]
+    [Ignore("getting CI working")]
+    public class TestCaseHyperdash : Game.Tests.Visual.TestCasePlayer
+    {
+        public TestCaseHyperdash()
+            : base(typeof(CatchRuleset))
+        {
+        }
+
+        protected override Beatmap CreateBeatmap()
+        {
+            var beatmap = new Beatmap();
+
+            for (int i = 0; i < 512; i++)
+                if (i % 5 < 3)
+                    beatmap.HitObjects.Add(new Fruit { X = i % 10 < 5 ? 0.02f : 0.98f, StartTime = i * 100, NewCombo = i % 8 == 0 });
+
+            return beatmap;
+        }
+    }
+}

osu.Game.Rulesets.Catch/UI/CatchPlayfield.cs

@@ -15,7 +15,7 @@ namespace osu.Game.Rulesets.Catch.UI
 {
     public class CatchPlayfield : ScrollingPlayfield
     {
-        public static readonly float BASE_WIDTH = 512;
+        public const float BASE_WIDTH = 512;
 
         protected override Container<Drawable> Content => content;
         private readonly Container<Drawable> content;
@@ -51,7 +51,7 @@ namespace osu.Game.Rulesets.Catch.UI
             };
         }
 
-        public bool CheckIfWeCanCatch(CatchHitObject obj) => catcherArea.CanCatch(obj);
+        public bool CheckIfWeCanCatch(CatchHitObject obj) => catcherArea.AttemptCatch(obj);
 
         public override void Add(DrawableHitObject h)
         {

osu.Game.Rulesets.Catch/UI/CatcherArea.cs

@@ -14,6 +14,7 @@ using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 using OpenTK;
+using OpenTK.Graphics;
 
 namespace osu.Game.Rulesets.Catch.UI
 {
@@ -21,18 +22,18 @@ namespace osu.Game.Rulesets.Catch.UI
     {
         public const float CATCHER_SIZE = 172;
 
-        private readonly Catcher catcher;
+        protected readonly Catcher MovableCatcher;
 
         public Container ExplodingFruitTarget
         {
-            set { catcher.ExplodingFruitTarget = value; }
+            set { MovableCatcher.ExplodingFruitTarget = value; }
         }
 
         public CatcherArea(BeatmapDifficulty difficulty = null)
         {
             RelativeSizeAxes = Axes.X;
             Height = CATCHER_SIZE;
-            Child = catcher = new Catcher(difficulty)
+            Child = MovableCatcher = new Catcher(difficulty)
             {
                 AdditiveTarget = this,
             };
@@ -41,17 +42,17 @@ namespace osu.Game.Rulesets.Catch.UI
         public void Add(DrawableHitObject fruit, Vector2 absolutePosition)
         {
             fruit.RelativePositionAxes = Axes.None;
-            fruit.Position = new Vector2(catcher.ToLocalSpace(absolutePosition).X - catcher.DrawSize.X / 2, 0);
+            fruit.Position = new Vector2(MovableCatcher.ToLocalSpace(absolutePosition).X - MovableCatcher.DrawSize.X / 2, 0);
 
             fruit.Anchor = Anchor.TopCentre;
             fruit.Origin = Anchor.BottomCentre;
             fruit.Scale *= 0.7f;
             fruit.LifetimeEnd = double.MaxValue;
 
-            catcher.Add(fruit);
+            MovableCatcher.Add(fruit);
         }
 
-        public bool CanCatch(CatchHitObject obj) => Math.Abs(catcher.Position.X - obj.X) < catcher.DrawSize.X * Math.Abs(catcher.Scale.X) / DrawSize.X / 2;
+        public bool AttemptCatch(CatchHitObject obj) => MovableCatcher.AttemptCatch(obj);
 
         public class Catcher : Container, IKeyBindingHandler<CatchAction>
         {
@@ -105,14 +106,35 @@ namespace osu.Game.Rulesets.Catch.UI
 
                     dashing = value;
 
-                    if (dashing)
+                    Trail |= dashing;
-                        Schedule(addAdditiveSprite);
                 }
             }
 
-            private void addAdditiveSprite()
+            private bool trail;
+
+            /// <summary>
+            /// Activate or deactive the trail. Will be automatically deactivated when conditions to keep the trail displayed are no longer met.
+            /// </summary>
+            protected bool Trail
             {
-                if (!dashing || AdditiveTarget == null) return;
+                get { return trail; }
+                set
+                {
+                    if (value == trail) return;
+
+                    trail = value;
+
+                    if (Trail)
+                        beginTrail();
+                }
+            }
+
+            private void beginTrail()
+            {
+                Trail &= dashing || HyperDashing;
+                Trail &= AdditiveTarget != null;
+
+                if (!Trail) return;
 
                 var additive = createCatcherSprite();
 
@@ -120,6 +142,7 @@ namespace osu.Game.Rulesets.Catch.UI
                 additive.OriginPosition = additive.OriginPosition + new Vector2(DrawWidth / 2, 0); // also temporary to align sprite correctly.
                 additive.Position = Position;
                 additive.Scale = Scale;
+                additive.Colour = HyperDashing ? Color4.Red : Color4.White;
                 additive.RelativePositionAxes = RelativePositionAxes;
                 additive.Blending = BlendingMode.Additive;
 
@@ -127,7 +150,7 @@ namespace osu.Game.Rulesets.Catch.UI
 
                 additive.FadeTo(0.4f).FadeOut(800, Easing.OutQuint).Expire();
 
-                Scheduler.AddDelayed(addAdditiveSprite, 50);
+                Scheduler.AddDelayed(beginTrail, HyperDashing ? 25 : 50);
             }
 
             private Sprite createCatcherSprite() => new Sprite
@@ -138,6 +161,10 @@ namespace osu.Game.Rulesets.Catch.UI
                 OriginPosition = new Vector2(-3, 10) // temporary until the sprite is aligned correctly.
             };
 
+            /// <summary>
+            /// Add a caught fruit to the catcher's stack.
+            /// </summary>
+            /// <param name="fruit">The fruit that was caught.</param>
             public void Add(DrawableHitObject fruit)
             {
                 float distance = fruit.DrawSize.X / 2 * fruit.Scale.X;
@@ -150,10 +177,80 @@ namespace osu.Game.Rulesets.Catch.UI
 
                 caughtFruit.Add(fruit);
 
-                if (((CatchHitObject)fruit.HitObject).LastInCombo)
+                var catchObject = (CatchHitObject)fruit.HitObject;
+
+                if (catchObject.LastInCombo)
                     explode();
             }
 
+            /// <summary>
+            /// Let the catcher attempt to catch a fruit.
+            /// </summary>
+            /// <param name="fruit">The fruit to catch.</param>
+            /// <returns>Whether the catch is possible.</returns>
+            public bool AttemptCatch(CatchHitObject fruit)
+            {
+                const double relative_catcher_width = CATCHER_SIZE / 2;
+
+                // this stuff wil disappear once we move fruit to non-relative coordinate space in the future.
+                var catchObjectPosition = fruit.X * CatchPlayfield.BASE_WIDTH;
+                var catcherPosition = Position.X * CatchPlayfield.BASE_WIDTH;
+
+                var validCatch =
+                    catchObjectPosition >= catcherPosition - relative_catcher_width / 2 &&
+                    catchObjectPosition <= catcherPosition + relative_catcher_width / 2;
+
+                if (validCatch && fruit.HyperDash)
+                {
+                    HyperDashModifier = Math.Abs(fruit.HyperDashTarget.X - fruit.X) / Math.Abs(fruit.HyperDashTarget.StartTime - fruit.StartTime) / BASE_SPEED;
+                    HyperDashDirection = fruit.HyperDashTarget.X - fruit.X;
+                }
+                else
+                    HyperDashModifier = 1;
+
+                return validCatch;
+            }
+
+            /// <summary>
+            /// Whether we are hypderdashing or not.
+            /// </summary>
+            public bool HyperDashing => hyperDashModifier != 1;
+
+            private double hyperDashModifier = 1;
+
+            /// <summary>
+            /// The direction in which hyperdash is allowed. 0 allows both directions.
+            /// </summary>
+            public double HyperDashDirection;
+
+            /// <summary>
+            /// The speed modifier resultant from hyperdash. Will trigger hyperdash when not equal to 1.
+            /// </summary>
+            public double HyperDashModifier
+            {
+                get { return hyperDashModifier; }
+                set
+                {
+                    if (value == hyperDashModifier) return;
+                    hyperDashModifier = value;
+
+                    const float transition_length = 180;
+
+                    if (HyperDashing)
+                    {
+                        this.FadeColour(Color4.OrangeRed, transition_length, Easing.OutQuint);
+                        this.FadeTo(0.2f, transition_length, Easing.OutQuint);
+                        Trail = true;
+                    }
+                    else
+                    {
+                        HyperDashDirection = 0;
+                        this.FadeColour(Color4.White, transition_length, Easing.OutQuint);
+                        this.FadeTo(1, transition_length, Easing.OutQuint);
+                    }
+                }
+            }
+
             public bool OnPressed(CatchAction action)
             {
                 switch (action)
@@ -201,10 +298,15 @@ namespace osu.Game.Rulesets.Catch.UI
 
                 if (currentDirection == 0) return;
 
+                var direction = Math.Sign(currentDirection);
+
                 double dashModifier = Dashing ? 1 : 0.5;
 
-                Scale = new Vector2(Math.Abs(Scale.X) * Math.Sign(currentDirection), Scale.Y);
+                if (hyperDashModifier != 1 && (HyperDashDirection == 0 || direction == Math.Sign(HyperDashDirection)))
-                X = (float)MathHelper.Clamp(X + Math.Sign(currentDirection) * Clock.ElapsedFrameTime * BASE_SPEED * dashModifier, 0, 1);
+                    dashModifier = hyperDashModifier;
+
+                Scale = new Vector2(Math.Abs(Scale.X) * direction, Scale.Y);
+                X = (float)MathHelper.Clamp(X + direction * Clock.ElapsedFrameTime * BASE_SPEED * dashModifier, 0, 1);
             }
 
             private void explode()

osu.Game.Rulesets.Catch/osu.Game.Rulesets.Catch.csproj

@@ -66,6 +66,7 @@
     <Compile Include="Tests\TestCaseCatchStacker.cs" />
     <Compile Include="Tests\TestCasePerformancePoints.cs" />
     <Compile Include="Tests\TestCaseCatchPlayer.cs" />
+    <Compile Include="Tests\TestCaseHyperdash.cs" />
     <Compile Include="UI\CatcherArea.cs" />
     <Compile Include="UI\CatchRulesetContainer.cs" />
     <Compile Include="UI\CatchPlayfield.cs" />