Merge branch 'master' into master

osu.Game.Rulesets.Mania.Tests/TestCaseHoldNotePlacementBlueprint.cs

@@ -0,0 +1,18 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Mania.Edit.Blueprints;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Drawables;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    public class TestCaseHoldNotePlacementBlueprint : ManiaPlacementBlueprintTestCase
+    {
+        protected override DrawableHitObject CreateHitObject(HitObject hitObject) => new DrawableHoldNote((HoldNote)hitObject);
+        protected override PlacementBlueprint CreateBlueprint() => new HoldNotePlacementBlueprint();
+    }
+}

osu.Game.Rulesets.Mania/Edit/Blueprints/Components/EditBodyPiece.cs

@@ -0,0 +1,21 @@
+// Copyright (c) 2007-2018 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 osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
+
+namespace osu.Game.Rulesets.Mania.Edit.Blueprints.Components
+{
+    public class EditBodyPiece : BodyPiece
+    {
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            AccentColour = colours.Yellow;
+
+            Background.Alpha = 0.5f;
+            Foreground.Alpha = 0;
+        }
+    }
+}

osu.Game.Rulesets.Mania/Edit/Blueprints/HoldNotePlacementBlueprint.cs

@@ -0,0 +1,74 @@
+// Copyright (c) 2007-2018 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.Framework.Input.Events;
+using osu.Game.Rulesets.Mania.Edit.Blueprints.Components;
+using osu.Game.Rulesets.Mania.Objects;
+using osuTK;
+
+namespace osu.Game.Rulesets.Mania.Edit.Blueprints
+{
+    public class HoldNotePlacementBlueprint : ManiaPlacementBlueprint<HoldNote>
+    {
+        private readonly EditBodyPiece bodyPiece;
+        private readonly EditNotePiece headPiece;
+        private readonly EditNotePiece tailPiece;
+
+        public HoldNotePlacementBlueprint()
+            : base(new HoldNote())
+        {
+            RelativeSizeAxes = Axes.Both;
+
+            InternalChildren = new Drawable[]
+            {
+                bodyPiece = new EditBodyPiece { Origin = Anchor.TopCentre },
+                headPiece = new EditNotePiece { Origin = Anchor.Centre },
+                tailPiece = new EditNotePiece { Origin = Anchor.Centre }
+            };
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            if (Column != null)
+            {
+                headPiece.Y = PositionAt(HitObject.StartTime);
+                tailPiece.Y = PositionAt(HitObject.EndTime);
+            }
+
+            var topPosition = new Vector2(headPiece.DrawPosition.X, Math.Min(headPiece.DrawPosition.Y, tailPiece.DrawPosition.Y));
+            var bottomPosition = new Vector2(headPiece.DrawPosition.X, Math.Max(headPiece.DrawPosition.Y, tailPiece.DrawPosition.Y));
+
+            bodyPiece.Position = topPosition;
+            bodyPiece.Width = headPiece.Width;
+            bodyPiece.Height = (bottomPosition - topPosition).Y;
+        }
+
+        private double originalStartTime;
+
+        protected override bool OnMouseMove(MouseMoveEvent e)
+        {
+            base.OnMouseMove(e);
+
+            if (PlacementBegun)
+            {
+                var endTime = TimeAt(e.ScreenSpaceMousePosition);
+
+                HitObject.StartTime = endTime < originalStartTime ? endTime : originalStartTime;
+                HitObject.Duration = Math.Abs(endTime - originalStartTime);
+            }
+            else
+            {
+                headPiece.Width = tailPiece.Width = SnappedWidth;
+                headPiece.X = tailPiece.X = SnappedMousePosition.X;
+
+                originalStartTime = HitObject.StartTime = TimeAt(e.ScreenSpaceMousePosition);
+            }
+
+            return true;
+        }
+    }
+}

osu.Game.Rulesets.Mania/Edit/Blueprints/ManiaPlacementBlueprint.cs

@@ -3,6 +3,7 @@
 
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
+using osu.Framework.Input;
 using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Mania.Objects;
@@ -13,11 +14,14 @@ using osuTK;
 
 namespace osu.Game.Rulesets.Mania.Edit.Blueprints
 {
-    public abstract class ManiaPlacementBlueprint<T> : PlacementBlueprint
+    public abstract class ManiaPlacementBlueprint<T> : PlacementBlueprint,
+                                                       IRequireHighFrequencyMousePosition // the playfield could be moving behind us
         where T : ManiaHitObject
     {
         protected new T HitObject => (T)base.HitObject;
 
+        protected Column Column;
+
         /// <summary>
         /// The current mouse position, snapped to the closest column.
         /// </summary>
@@ -40,31 +44,49 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
             RelativeSizeAxes = Axes.None;
         }
 
+        protected override bool OnMouseDown(MouseDownEvent e)
+        {
+            if (Column == null)
+                return base.OnMouseDown(e);
+
+            HitObject.StartTime = TimeAt(e.ScreenSpaceMousePosition);
+            HitObject.Column = Column.Index;
+
+            BeginPlacement();
+            return true;
+        }
+
+        protected override bool OnMouseUp(MouseUpEvent e)
+        {
+            EndPlacement();
+            return base.OnMouseUp(e);
+        }
+
         protected override bool OnMouseMove(MouseMoveEvent e)
         {
-            Column column = ColumnAt(e.ScreenSpaceMousePosition);
+            if (!PlacementBegun)
+                Column = ColumnAt(e.ScreenSpaceMousePosition);
 
-            if (column == null) return false;
+            if (Column == null) return false;
 
-            SnappedWidth = column.DrawWidth;
+            SnappedWidth = Column.DrawWidth;
 
             // Snap to the column
-            var parentPos = Parent.ToLocalSpace(column.ToScreenSpace(new Vector2(column.DrawWidth / 2, 0)));
+            var parentPos = Parent.ToLocalSpace(Column.ToScreenSpace(new Vector2(Column.DrawWidth / 2, 0)));
             SnappedMousePosition = new Vector2(parentPos.X, e.MousePosition.Y);
             return true;
         }
 
         protected double TimeAt(Vector2 screenSpacePosition)
         {
-            var column = ColumnAt(screenSpacePosition);
+            if (Column == null)
-            if (column == null)
                 return 0;
 
-            var hitObjectContainer = column.HitObjectContainer;
+            var hitObjectContainer = Column.HitObjectContainer;
 
             // If we're scrolling downwards, a position of 0 is actually further away from the hit target
             // so we need to flip the vertical coordinate in the hitobject container's space
-            var hitObjectPos = column.HitObjectContainer.ToLocalSpace(applyPositionOffset(screenSpacePosition)).Y;
+            var hitObjectPos = Column.HitObjectContainer.ToLocalSpace(applyPositionOffset(screenSpacePosition, false)).Y;
             if (scrollingInfo.Direction.Value == ScrollingDirection.Down)
                 hitObjectPos = hitObjectContainer.DrawHeight - hitObjectPos;
 
@@ -74,21 +96,22 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
                 hitObjectContainer.DrawHeight);
         }
 
-        protected Column ColumnAt(Vector2 screenSpacePosition)
+        protected float PositionAt(double time)
-            => composer.ColumnAt(applyPositionOffset(screenSpacePosition));
-
-        private Vector2 applyPositionOffset(Vector2 position)
         {
-            switch (scrollingInfo.Direction.Value)
+            var pos = scrollingInfo.Algorithm.PositionAt(time,
-            {
+                EditorClock.CurrentTime,
-                case ScrollingDirection.Up:
+                scrollingInfo.TimeRange.Value,
-                    position.Y -= NotePiece.NOTE_HEIGHT / 2;
+                Column.HitObjectContainer.DrawHeight);
-                    break;
-                case ScrollingDirection.Down:
-                    position.Y += NotePiece.NOTE_HEIGHT / 2;
-                    break;
-            }
 
+            return applyPositionOffset(Column.HitObjectContainer.ToSpaceOfOtherDrawable(new Vector2(0, pos), Parent), true).Y;
+        }
+
+        protected Column ColumnAt(Vector2 screenSpacePosition)
+            => composer.ColumnAt(applyPositionOffset(screenSpacePosition, false));
+
+        private Vector2 applyPositionOffset(Vector2 position, bool reverse)
+        {
+            position.Y += (scrollingInfo.Direction.Value == ScrollingDirection.Up && !reverse ? -1 : 1) * NotePiece.NOTE_HEIGHT / 2;
             return position;
         }
     }

osu.Game.Rulesets.Mania/Edit/Blueprints/NotePlacementBlueprint.cs

@@ -2,10 +2,8 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using osu.Framework.Graphics;
-using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Mania.Edit.Blueprints.Components;
 using osu.Game.Rulesets.Mania.Objects;
-using osu.Game.Rulesets.Mania.UI;
 
 namespace osu.Game.Rulesets.Mania.Edit.Blueprints
 {
@@ -28,19 +26,5 @@ namespace osu.Game.Rulesets.Mania.Edit.Blueprints
             Width = SnappedWidth;
             Position = SnappedMousePosition;
         }
-
-        protected override bool OnClick(ClickEvent e)
-        {
-            Column column;
-            if ((column = ColumnAt(e.ScreenSpaceMousePosition)) == null)
-                return base.OnClick(e);
-
-            HitObject.StartTime = TimeAt(e.ScreenSpaceMousePosition);
-            HitObject.Column = column.Index;
-
-            EndPlacement();
-
-            return true;
-        }
     }
 }

osu.Game.Rulesets.Mania/Edit/HoldNoteCompositionTool.cs

@@ -0,0 +1,19 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Edit.Tools;
+using osu.Game.Rulesets.Mania.Edit.Blueprints;
+
+namespace osu.Game.Rulesets.Mania.Edit
+{
+    public class HoldNoteCompositionTool : HitObjectCompositionTool
+    {
+        public HoldNoteCompositionTool()
+            : base("Hold")
+        {
+        }
+
+        public override PlacementBlueprint CreatePlacementBlueprint() => new HoldNotePlacementBlueprint();
+    }
+}

osu.Game.Rulesets.Mania/Edit/ManiaHitObjectComposer.cs

@@ -50,7 +50,8 @@ namespace osu.Game.Rulesets.Mania.Edit
 
         protected override IReadOnlyList<HitObjectCompositionTool> CompositionTools => new HitObjectCompositionTool[]
         {
-            new NoteCompositionTool()
+            new NoteCompositionTool(),
+            new HoldNoteCompositionTool()
         };
 
         public override SelectionBlueprint CreateBlueprintFor(DrawableHitObject hitObject)

osu.Game.Rulesets.Mania/Objects/Drawables/Pieces/BodyPiece.cs

@@ -15,12 +15,12 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables.Pieces
     /// <summary>
     /// Represents length-wise portion of a hold note.
     /// </summary>
-    internal class BodyPiece : Container, IHasAccentColour
+    public class BodyPiece : Container, IHasAccentColour
     {
         private readonly Container subtractionLayer;
 
-        private readonly Drawable background;
+        protected readonly Drawable Background;
-        private readonly BufferedContainer foreground;
+        protected readonly BufferedContainer Foreground;
         private readonly BufferedContainer subtractionContainer;
 
         public BodyPiece()
@@ -29,8 +29,8 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables.Pieces
 
             Children = new[]
             {
-                background = new Box { RelativeSizeAxes = Axes.Both },
+                Background = new Box { RelativeSizeAxes = Axes.Both },
-                foreground = new BufferedContainer
+                Foreground = new BufferedContainer
                 {
                     Blending = BlendingMode.Additive,
                     RelativeSizeAxes = Axes.Both,
@@ -123,7 +123,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables.Pieces
                     Radius = DrawWidth
                 };
 
-                foreground.ForceRedraw();
+                Foreground.ForceRedraw();
                 subtractionContainer.ForceRedraw();
 
                 subtractionCache.Validate();
@@ -137,18 +137,18 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables.Pieces
             if (!IsLoaded)
                 return;
 
-            foreground.Colour = AccentColour.Opacity(0.5f);
+            Foreground.Colour = AccentColour.Opacity(0.5f);
-            background.Colour = AccentColour.Opacity(0.7f);
+            Background.Colour = AccentColour.Opacity(0.7f);
 
             const float animation_length = 50;
 
-            foreground.ClearTransforms(false, nameof(foreground.Colour));
+            Foreground.ClearTransforms(false, nameof(Foreground.Colour));
             if (hitting)
             {
                 // wait for the next sync point
                 double synchronisedOffset = animation_length * 2 - Time.Current % (animation_length * 2);
-                using (foreground.BeginDelayedSequence(synchronisedOffset))
+                using (Foreground.BeginDelayedSequence(synchronisedOffset))
-                    foreground.FadeColour(AccentColour.Lighten(0.2f), animation_length).Then().FadeColour(foreground.Colour, animation_length).Loop();
+                    Foreground.FadeColour(AccentColour.Lighten(0.2f), animation_length).Then().FadeColour(Foreground.Colour, animation_length).Loop();
             }
 
             subtractionCache.Invalidate();