Add back CatcherArea to simplify layout

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

@@ -8,17 +8,16 @@ using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Tests.Visual;
-using OpenTK;
 
 namespace osu.Game.Rulesets.Catch.Tests
 {
     [TestFixture]
     [Ignore("getting CI working")]
-    internal class TestCaseCatcher : OsuTestCase
+    internal class TestCaseCatcherArea : OsuTestCase
     {
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {
-            typeof(Catcher),
+            typeof(CatcherArea),
         };
 
         [BackgroundDependencyLoader]
@@ -29,13 +28,10 @@ namespace osu.Game.Rulesets.Catch.Tests
                 new CatchInputManager(rulesets.GetRuleset(2))
                 {
                     RelativeSizeAxes = Axes.Both,
-                    Child = new Catcher
+                    Child = new CatcherArea()
                     {
-                        RelativePositionAxes = Axes.Both,
-                        RelativeSizeAxes = Axes.Both,
                         Anchor = Anchor.BottomLeft,
-                        Origin = Anchor.BottomLeft,
+                        Origin = Anchor.BottomLeft
-                        Size = new Vector2(1, 0.2f),
                     }
                 },
             };

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

@@ -1,11 +1,11 @@
 // 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.Framework.Graphics;
 using osu.Game.Rulesets.UI;
 using OpenTK;
 using osu.Framework.Graphics.Containers;
+using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Objects.Drawable;
 using osu.Game.Rulesets.Judgements;
@@ -20,10 +20,9 @@ namespace osu.Game.Rulesets.Catch.UI
         protected override Container<Drawable> Content => content;
         private readonly Container<Drawable> content;
 
-        private readonly Container catcherContainer;
+        private readonly CatcherArea catcherArea;
-        private readonly Catcher catcher;
 
-        public CatchPlayfield()
+        public CatchPlayfield(BeatmapDifficulty difficulty)
             : base(Axes.Y)
         {
             Container explodingFruitContainer;
@@ -43,19 +42,11 @@ namespace osu.Game.Rulesets.Catch.UI
                 {
                     RelativeSizeAxes = Axes.Both,
                 },
-                catcherContainer = new Container
+                catcherArea = new CatcherArea(difficulty)
                 {
-                    RelativeSizeAxes = Axes.X,
+                    ExplodingFruitTarget = explodingFruitContainer,
                     Anchor = Anchor.BottomLeft,
                     Origin = Anchor.TopLeft,
-                    Height = 180,
-                    Child = catcher = new Catcher
-                    {
-                        ExplodingFruitTarget = explodingFruitContainer,
-                        RelativePositionAxes = Axes.Both,
-                        Origin = Anchor.TopCentre,
-                        X = 0.5f,
-                    }
                 }
             };
         }
@@ -63,10 +54,9 @@ namespace osu.Game.Rulesets.Catch.UI
         protected override void Update()
         {
             base.Update();
-            catcher.Size = new Vector2(catcherContainer.DrawSize.Y);
         }
 
-        public bool CheckIfWeCanCatch(CatchHitObject obj) => Math.Abs(catcher.Position.X - obj.X) < catcher.DrawSize.X / DrawSize.X / 2;
+        public bool CheckIfWeCanCatch(CatchHitObject obj) => catcherArea.CanCatch(obj);
 
         public override void Add(DrawableHitObject h)
         {
@@ -88,7 +78,7 @@ namespace osu.Game.Rulesets.Catch.UI
                 (judgedObject.Parent as Container<DrawableHitObject>)?.Remove(judgedObject);
                 (judgedObject.Parent as Container)?.Remove(judgedObject);
 
-                catcher.Add(judgedObject, screenPosition);
+                catcherArea.Add(judgedObject, screenPosition);
             }
         }
     }

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

@@ -26,7 +26,7 @@ namespace osu.Game.Rulesets.Catch.UI
 
         protected override BeatmapConverter<CatchHitObject> CreateBeatmapConverter() => new CatchBeatmapConverter();
 
-        protected override Playfield CreatePlayfield() => new CatchPlayfield();
+        protected override Playfield CreatePlayfield() => new CatchPlayfield(Beatmap.BeatmapInfo.BaseDifficulty);
 
         public override PassThroughInputManager CreateInputManager() => new CatchInputManager(Ruleset.RulesetInfo);
 

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

@@ -1,193 +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 System;
-using System.Linq;
-using osu.Framework.Allocation;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Sprites;
-using osu.Framework.Graphics.Textures;
-using osu.Framework.Input.Bindings;
-using osu.Framework.MathUtils;
-using osu.Game.Rulesets.Catch.Objects;
-using osu.Game.Rulesets.Objects.Drawables;
-using OpenTK;
-
-namespace osu.Game.Rulesets.Catch.UI
-{
-    public class Catcher : Container, IKeyBindingHandler<CatchAction>
-    {
-        private Texture texture;
-
-        private Container<DrawableHitObject> caughtFruit;
-
-        public Container ExplodingFruitTarget;
-
-        [BackgroundDependencyLoader]
-        private void load(TextureStore textures)
-        {
-            texture = textures.Get(@"Play/Catch/fruit-catcher-idle");
-
-            Children = new Drawable[]
-            {
-                createCatcherSprite(),
-                caughtFruit = new Container<DrawableHitObject>
-                {
-                    Anchor = Anchor.TopCentre,
-                    Origin = Anchor.BottomCentre,
-                }
-            };
-        }
-
-        private int currentDirection;
-
-        private bool dashing;
-
-        protected bool Dashing
-        {
-            get { return dashing; }
-            set
-            {
-                if (value == dashing) return;
-
-                dashing = value;
-
-                if (dashing)
-                    Schedule(addAdditiveSprite);
-            }
-        }
-
-        private void addAdditiveSprite()
-        {
-            if (!dashing) return;
-
-            var additive = createCatcherSprite();
-
-            additive.RelativePositionAxes = Axes.Both;
-            additive.Blending = BlendingMode.Additive;
-            additive.Position = Position;
-            additive.Scale = Scale;
-
-            ((Container)Parent).Add(additive);
-
-            additive.FadeTo(0.4f).FadeOut(800, Easing.OutQuint).Expire();
-
-            Scheduler.AddDelayed(addAdditiveSprite, 50);
-        }
-
-        private Sprite createCatcherSprite() => new Sprite
-        {
-            RelativeSizeAxes = Axes.Both,
-            FillMode = FillMode.Fit,
-            Texture = texture,
-            OriginPosition = new Vector2(DrawWidth / 2, 10) //temporary until the sprite is aligned correctly.
-        };
-
-        public bool OnPressed(CatchAction action)
-        {
-            switch (action)
-            {
-                case CatchAction.MoveLeft:
-                    currentDirection--;
-                    return true;
-                case CatchAction.MoveRight:
-                    currentDirection++;
-                    return true;
-                case CatchAction.Dash:
-                    Dashing = true;
-                    return true;
-            }
-
-            return false;
-        }
-
-        public bool OnReleased(CatchAction action)
-        {
-            switch (action)
-            {
-                case CatchAction.MoveLeft:
-                    currentDirection++;
-                    return true;
-                case CatchAction.MoveRight:
-                    currentDirection--;
-                    return true;
-                case CatchAction.Dash:
-                    Dashing = false;
-                    return true;
-            }
-
-            return false;
-        }
-
-        /// <summary>
-        /// The relative space to cover in 1 millisecond. based on 1 game pixel per millisecond as in osu-stable.
-        /// </summary>
-        private const double base_speed = 1.0 / 512;
-
-        protected override void Update()
-        {
-            base.Update();
-
-            if (currentDirection == 0) return;
-
-            double dashModifier = Dashing ? 1 : 0.5;
-
-            Scale = new Vector2(Math.Sign(currentDirection), 1);
-            X = (float)MathHelper.Clamp(X + Math.Sign(currentDirection) * Clock.ElapsedFrameTime * base_speed * dashModifier, 0, 1);
-        }
-
-        public void Add(DrawableHitObject fruit, Vector2 absolutePosition)
-        {
-            fruit.RelativePositionAxes = Axes.None;
-            fruit.Position = new Vector2(ToLocalSpace(absolutePosition).X - DrawSize.X / 2, 0);
-
-            fruit.Anchor = Anchor.TopCentre;
-            fruit.Origin = Anchor.BottomCentre;
-            fruit.Scale *= 0.7f;
-            fruit.LifetimeEnd = double.MaxValue;
-
-            float distance = fruit.DrawSize.X / 2 * fruit.Scale.X;
-
-            while (caughtFruit.Any(f => f.LifetimeEnd == double.MaxValue && Vector2Extensions.DistanceSquared(f.Position, fruit.Position) < distance * distance))
-            {
-                fruit.X += RNG.Next(-5, 5);
-                fruit.Y -= RNG.Next(0, 5);
-            }
-
-            caughtFruit.Add(fruit);
-
-            if (((CatchHitObject)fruit.HitObject).LastInCombo)
-                explode();
-        }
-
-        private void explode()
-        {
-            var fruit = caughtFruit.ToArray();
-
-            foreach (var f in fruit)
-            {
-                var originalX = f.X * Scale.X;
-
-                if (ExplodingFruitTarget != null)
-                {
-                    f.Anchor = Anchor.TopLeft;
-                    f.Position = caughtFruit.ToSpaceOfOtherDrawable(f.DrawPosition, ExplodingFruitTarget);
-
-                    caughtFruit.Remove(f);
-
-                    ExplodingFruitTarget.Add(f);
-                }
-
-                f.MoveToY(f.Y - 50, 250, Easing.OutSine)
-                .Then()
-                .MoveToY(f.Y + 50, 500, Easing.InSine);
-
-                f.MoveToX(f.X + originalX * 6, 1000);
-                f.FadeOut(750);
-
-                f.Expire();
-            }
-        }
-    }
-}

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

@@ -0,0 +1,238 @@
+// 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.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.Textures;
+using osu.Framework.Input.Bindings;
+using osu.Framework.MathUtils;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Objects.Drawables;
+using OpenTK;
+
+namespace osu.Game.Rulesets.Catch.UI
+{
+    public class CatcherArea : Container
+    {
+        public const float CATCHER_SIZE = 172;
+
+        private readonly Catcher catcher;
+
+        public Container ExplodingFruitTarget
+        {
+            set { catcher.ExplodingFruitTarget = value; }
+        }
+
+        public CatcherArea(BeatmapDifficulty difficulty = null)
+        {
+            RelativeSizeAxes = Axes.X;
+            Height = CATCHER_SIZE;
+            Child = catcher = new Catcher(difficulty)
+            {
+                AdditiveTarget = this,
+            };
+        }
+
+        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.Anchor = Anchor.TopCentre;
+            fruit.Origin = Anchor.BottomCentre;
+            fruit.Scale *= 0.7f;
+            fruit.LifetimeEnd = double.MaxValue;
+
+            catcher.Add(fruit);
+        }
+
+        public bool CanCatch(CatchHitObject obj) => Math.Abs(catcher.Position.X - obj.X) < catcher.DrawSize.X / DrawSize.X / 2;
+
+        public class Catcher : Container, IKeyBindingHandler<CatchAction>
+        {
+            private Texture texture;
+
+            private Container<DrawableHitObject> caughtFruit;
+
+            public Container ExplodingFruitTarget;
+
+            public Container AdditiveTarget;
+
+            public Catcher(BeatmapDifficulty difficulty = null)
+            {
+                RelativePositionAxes = Axes.X;
+                X = 0.5f;
+
+                Origin = Anchor.BottomCentre;
+                Anchor = Anchor.BottomLeft;
+
+                Size = new Vector2(CATCHER_SIZE);
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(TextureStore textures)
+            {
+                texture = textures.Get(@"Play/Catch/fruit-catcher-idle");
+
+                Children = new Drawable[]
+                {
+                    createCatcherSprite(),
+                    caughtFruit = new Container<DrawableHitObject>
+                    {
+                        Anchor = Anchor.TopCentre,
+                        Origin = Anchor.BottomCentre,
+                    }
+                };
+            }
+
+            private int currentDirection;
+
+            private bool dashing;
+
+            protected bool Dashing
+            {
+                get { return dashing; }
+                set
+                {
+                    if (value == dashing) return;
+
+                    dashing = value;
+
+                    if (dashing)
+                        Schedule(addAdditiveSprite);
+                }
+            }
+
+            private void addAdditiveSprite()
+            {
+                if (!dashing || AdditiveTarget == null) return;
+
+                var additive = createCatcherSprite();
+
+                additive.Anchor = Anchor;
+                additive.OriginPosition = additive.OriginPosition + new Vector2(DrawWidth / 2, DrawHeight); // also temporary to align sprite correctly.
+                additive.Position = Position;
+                additive.Scale = Scale;
+                additive.RelativePositionAxes = RelativePositionAxes;
+                additive.Blending = BlendingMode.Additive;
+
+                AdditiveTarget.Add(additive);
+
+                additive.FadeTo(0.4f).FadeOut(800, Easing.OutQuint).Expire();
+
+                Scheduler.AddDelayed(addAdditiveSprite, 50);
+            }
+
+            private Sprite createCatcherSprite() => new Sprite
+            {
+                Size = new Vector2(CATCHER_SIZE),
+                FillMode = FillMode.Fill,
+                Texture = texture,
+                OriginPosition = new Vector2(-3, 10) // temporary until the sprite is aligned correctly.
+            };
+
+            public void Add(DrawableHitObject fruit)
+            {
+                float distance = fruit.DrawSize.X / 2 * fruit.Scale.X;
+
+                while (caughtFruit.Any(f => f.LifetimeEnd == double.MaxValue && Vector2Extensions.DistanceSquared(f.Position, fruit.Position) < distance * distance))
+                {
+                    fruit.X += RNG.Next(-5, 5);
+                    fruit.Y -= RNG.Next(0, 5);
+                }
+
+                caughtFruit.Add(fruit);
+
+                if (((CatchHitObject)fruit.HitObject).LastInCombo)
+                    explode();
+            }
+
+            public bool OnPressed(CatchAction action)
+            {
+                switch (action)
+                {
+                    case CatchAction.MoveLeft:
+                        currentDirection--;
+                        return true;
+                    case CatchAction.MoveRight:
+                        currentDirection++;
+                        return true;
+                    case CatchAction.Dash:
+                        Dashing = true;
+                        return true;
+                }
+
+                return false;
+            }
+
+            public bool OnReleased(CatchAction action)
+            {
+                switch (action)
+                {
+                    case CatchAction.MoveLeft:
+                        currentDirection++;
+                        return true;
+                    case CatchAction.MoveRight:
+                        currentDirection--;
+                        return true;
+                    case CatchAction.Dash:
+                        Dashing = false;
+                        return true;
+                }
+
+                return false;
+            }
+
+            /// <summary>
+            /// The relative space to cover in 1 millisecond. based on 1 game pixel per millisecond as in osu-stable.
+            /// </summary>
+            public const double BASE_SPEED = 1.0 / 512;
+
+            protected override void Update()
+            {
+                base.Update();
+
+                if (currentDirection == 0) return;
+
+                double dashModifier = Dashing ? 1 : 0.5;
+
+                Scale = new Vector2(Math.Sign(currentDirection), 1);
+                X = (float)MathHelper.Clamp(X + Math.Sign(currentDirection) * Clock.ElapsedFrameTime * BASE_SPEED * dashModifier, 0, 1);
+            }
+
+            private void explode()
+            {
+                var fruit = caughtFruit.ToArray();
+
+                foreach (var f in fruit)
+                {
+                    var originalX = f.X * Scale.X;
+
+                    if (ExplodingFruitTarget != null)
+                    {
+                        f.Anchor = Anchor.TopLeft;
+                        f.Position = caughtFruit.ToSpaceOfOtherDrawable(f.DrawPosition, ExplodingFruitTarget);
+
+                        caughtFruit.Remove(f);
+
+                        ExplodingFruitTarget.Add(f);
+                    }
+
+                    f.MoveToY(f.Y - 50, 250, Easing.OutSine)
+                     .Then()
+                     .MoveToY(f.Y + 50, 500, Easing.InSine);
+
+                    f.MoveToX(f.X + originalX * 6, 1000);
+                    f.FadeOut(750);
+
+                    f.Expire();
+                }
+            }
+        }
+    }
+}

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

@@ -63,10 +63,10 @@
     <Compile Include="Objects\Fruit.cs" />
     <Compile Include="Objects\TinyDroplet.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="Tests\TestCaseCatcher.cs" />
+    <Compile Include="Tests\TestCaseCatcherArea.cs" />
     <Compile Include="Tests\TestCaseCatchStacker.cs" />
     <Compile Include="Tests\TestCaseCatchPlayer.cs" />
-    <Compile Include="UI\Catcher.cs" />
+    <Compile Include="UI\CatcherArea.cs" />
     <Compile Include="UI\CatchRulesetContainer.cs" />
     <Compile Include="UI\CatchPlayfield.cs" />
     <Compile Include="CatchRuleset.cs" />