Merge branch 'master' into tablet-rotation-configuration

osu.Game.Rulesets.Catch/Mods/CatchModHidden.cs

@@ -3,13 +3,16 @@
 
 using System.Linq;
 using osu.Framework.Graphics;
+using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Objects.Drawables;
+using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.UI;
 
 namespace osu.Game.Rulesets.Catch.Mods
 {
-    public class CatchModHidden : ModHidden
+    public class CatchModHidden : ModHidden, IApplicableToDrawableRuleset<CatchHitObject>
     {
         public override string Description => @"Play with fading fruits.";
         public override double ScoreMultiplier => 1.06;
@@ -17,6 +20,14 @@ namespace osu.Game.Rulesets.Catch.Mods
         private const double fade_out_offset_multiplier = 0.6;
         private const double fade_out_duration_multiplier = 0.44;
 
+        public void ApplyToDrawableRuleset(DrawableRuleset<CatchHitObject> drawableRuleset)
+        {
+            var drawableCatchRuleset = (DrawableCatchRuleset)drawableRuleset;
+            var catchPlayfield = (CatchPlayfield)drawableCatchRuleset.Playfield;
+
+            catchPlayfield.CatcherArea.MovableCatcher.CatchFruitOnPlate = false;
+        }
+
         protected override void ApplyNormalVisibilityState(DrawableHitObject hitObject, ArmedState state)
         {
             base.ApplyNormalVisibilityState(hitObject, state);

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

@@ -43,6 +43,11 @@ namespace osu.Game.Rulesets.Catch.UI
         /// </summary>
         public bool HyperDashing => hyperDashModifier != 1;
 
+        /// <summary>
+        /// Whether <see cref="DrawablePalpableCatchHitObject"/> fruit should appear on the plate.
+        /// </summary>
+        public bool CatchFruitOnPlate { get; set; } = true;
+
         /// <summary>
         /// The relative space to cover in 1 millisecond. based on 1 game pixel per millisecond as in osu-stable.
         /// </summary>
@@ -237,7 +242,8 @@ namespace osu.Game.Rulesets.Catch.UI
             {
                 var positionInStack = computePositionInStack(new Vector2(palpableObject.X - X, 0), palpableObject.DisplaySize.X / 2);
 
-                placeCaughtObject(palpableObject, positionInStack);
+                if (CatchFruitOnPlate)
+                    placeCaughtObject(palpableObject, positionInStack);
 
                 if (hitLighting.Value)
                     addLighting(hitObject, positionInStack.X, drawableObject.AccentColour.Value);

osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmapConverter.cs

@@ -47,7 +47,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
 
             if (IsForCurrentRuleset)
             {
-                TargetColumns = (int)Math.Max(1, roundedCircleSize);
+                TargetColumns = GetColumnCountForNonConvert(beatmap.BeatmapInfo);
 
                 if (TargetColumns > ManiaRuleset.MAX_STAGE_KEYS)
                 {
@@ -71,6 +71,12 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
             originalTargetColumns = TargetColumns;
         }
 
+        public static int GetColumnCountForNonConvert(BeatmapInfo beatmap)
+        {
+            var roundedCircleSize = Math.Round(beatmap.BaseDifficulty.CircleSize);
+            return (int)Math.Max(1, roundedCircleSize);
+        }
+
         public override bool CanConvert() => Beatmap.HitObjects.All(h => h is IHasXPosition);
 
         protected override Beatmap<ManiaHitObject> ConvertBeatmap(IBeatmap original, CancellationToken cancellationToken)

osu.Game.Rulesets.Mania/ManiaFilterCriteria.cs

@@ -0,0 +1,33 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Filter;
+using osu.Game.Rulesets.Mania.Beatmaps;
+using osu.Game.Screens.Select;
+using osu.Game.Screens.Select.Filter;
+
+namespace osu.Game.Rulesets.Mania
+{
+    public class ManiaFilterCriteria : IRulesetFilterCriteria
+    {
+        private FilterCriteria.OptionalRange<float> keys;
+
+        public bool Matches(BeatmapInfo beatmap)
+        {
+            return !keys.HasFilter || (beatmap.RulesetID == new ManiaRuleset().LegacyID && keys.IsInRange(ManiaBeatmapConverter.GetColumnCountForNonConvert(beatmap)));
+        }
+
+        public bool TryParseCustomKeywordCriteria(string key, Operator op, string value)
+        {
+            switch (key)
+            {
+                case "key":
+                case "keys":
+                    return FilterQueryParser.TryUpdateCriteriaRange(ref keys, op, value);
+            }
+
+            return false;
+        }
+    }
+}

osu.Game.Rulesets.Mania/ManiaRuleset.cs

@@ -22,6 +22,7 @@ using osu.Game.Overlays.Settings;
 using osu.Game.Rulesets.Configuration;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Filter;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Configuration;
 using osu.Game.Rulesets.Mania.Difficulty;
@@ -382,6 +383,11 @@ namespace osu.Game.Rulesets.Mania
                 }
             }
         };
+
+        public override IRulesetFilterCriteria CreateRulesetFilterCriteria()
+        {
+            return new ManiaFilterCriteria();
+        }
     }
 
     public enum PlayfieldType

osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs

@@ -35,8 +35,18 @@ namespace osu.Game.Rulesets.Osu.Edit
             referenceOrigin = null;
         }
 
-        public override bool HandleMovement(MoveSelectionEvent moveEvent) =>
+        public override bool HandleMovement(MoveSelectionEvent moveEvent)
-            moveSelection(moveEvent.InstantDelta);
+        {
+            var hitObjects = selectedMovableObjects;
+
+            // this will potentially move the selection out of bounds...
+            foreach (var h in hitObjects)
+                h.Position += moveEvent.InstantDelta;
+
+            // but this will be corrected.
+            moveSelectionInBounds();
+            return true;
+        }
 
         /// <summary>
         /// During a transform, the initial origin is stored so it can be used throughout the operation.
@@ -140,36 +150,11 @@ namespace osu.Game.Rulesets.Osu.Edit
             // the only hit object selected. with a group selection, it's likely the user
             // is not looking to change the duration of the slider but expand the whole pattern.
             if (hitObjects.Length == 1 && hitObjects.First() is Slider slider)
-            {
+                scaleSlider(slider, scale);
-                Quad quad = getSurroundingQuad(slider.Path.ControlPoints.Select(p => p.Position.Value));
-                Vector2 pathRelativeDeltaScale = new Vector2(1 + scale.X / quad.Width, 1 + scale.Y / quad.Height);
-
-                foreach (var point in slider.Path.ControlPoints)
-                    point.Position.Value *= pathRelativeDeltaScale;
-            }
             else
-            {
+                scaleHitObjects(hitObjects, reference, scale);
-                // move the selection before scaling if dragging from top or left anchors.
-                if ((reference & Anchor.x0) > 0 && !moveSelection(new Vector2(-scale.X, 0))) return false;
-                if ((reference & Anchor.y0) > 0 && !moveSelection(new Vector2(0, -scale.Y))) return false;
-
-                Quad quad = getSurroundingQuad(hitObjects);
-
-                foreach (var h in hitObjects)
-                {
-                    var newPosition = h.Position;
-
-                    // guard against no-ops and NaN.
-                    if (scale.X != 0 && quad.Width > 0)
-                        newPosition.X = quad.TopLeft.X + (h.X - quad.TopLeft.X) / quad.Width * (quad.Width + scale.X);
-
-                    if (scale.Y != 0 && quad.Height > 0)
-                        newPosition.Y = quad.TopLeft.Y + (h.Y - quad.TopLeft.Y) / quad.Height * (quad.Height + scale.Y);
-
-                    h.Position = newPosition;
-                }
-            }
 
+            moveSelectionInBounds();
             return true;
         }
 
@@ -207,28 +192,124 @@ namespace osu.Game.Rulesets.Osu.Edit
             return true;
         }
 
-        private bool moveSelection(Vector2 delta)
+        private void scaleSlider(Slider slider, Vector2 scale)
+        {
+            Quad sliderQuad = getSurroundingQuad(slider.Path.ControlPoints.Select(p => p.Position.Value));
+
+            // Limit minimum distance between control points  after scaling to almost 0. Less than 0 causes the slider to flip, exactly 0 causes a crash through division by 0.
+            scale = Vector2.ComponentMax(new Vector2(Precision.FLOAT_EPSILON), sliderQuad.Size + scale) - sliderQuad.Size;
+
+            Vector2 pathRelativeDeltaScale = new Vector2(1 + scale.X / sliderQuad.Width, 1 + scale.Y / sliderQuad.Height);
+
+            Queue<Vector2> oldControlPoints = new Queue<Vector2>();
+
+            foreach (var point in slider.Path.ControlPoints)
+            {
+                oldControlPoints.Enqueue(point.Position.Value);
+                point.Position.Value *= pathRelativeDeltaScale;
+            }
+
+            //if sliderhead or sliderend end up outside playfield, revert scaling.
+            Quad scaledQuad = getSurroundingQuad(new OsuHitObject[] { slider });
+            (bool xInBounds, bool yInBounds) = isQuadInBounds(scaledQuad);
+
+            if (xInBounds && yInBounds)
+                return;
+
+            foreach (var point in slider.Path.ControlPoints)
+                point.Position.Value = oldControlPoints.Dequeue();
+        }
+
+        private void scaleHitObjects(OsuHitObject[] hitObjects, Anchor reference, Vector2 scale)
+        {
+            scale = getClampedScale(hitObjects, reference, scale);
+
+            // move the selection before scaling if dragging from top or left anchors.
+            float xOffset = ((reference & Anchor.x0) > 0) ? -scale.X : 0;
+            float yOffset = ((reference & Anchor.y0) > 0) ? -scale.Y : 0;
+
+            Quad selectionQuad = getSurroundingQuad(hitObjects);
+
+            foreach (var h in hitObjects)
+            {
+                var newPosition = h.Position;
+
+                // guard against no-ops and NaN.
+                if (scale.X != 0 && selectionQuad.Width > 0)
+                    newPosition.X = selectionQuad.TopLeft.X + xOffset + (h.X - selectionQuad.TopLeft.X) / selectionQuad.Width * (selectionQuad.Width + scale.X);
+
+                if (scale.Y != 0 && selectionQuad.Height > 0)
+                    newPosition.Y = selectionQuad.TopLeft.Y + yOffset + (h.Y - selectionQuad.TopLeft.Y) / selectionQuad.Height * (selectionQuad.Height + scale.Y);
+
+                h.Position = newPosition;
+            }
+        }
+
+        private (bool X, bool Y) isQuadInBounds(Quad quad)
+        {
+            bool xInBounds = (quad.TopLeft.X >= 0) && (quad.BottomRight.X <= DrawWidth);
+            bool yInBounds = (quad.TopLeft.Y >= 0) && (quad.BottomRight.Y <= DrawHeight);
+
+            return (xInBounds, yInBounds);
+        }
+
+        private void moveSelectionInBounds()
         {
             var hitObjects = selectedMovableObjects;
 
             Quad quad = getSurroundingQuad(hitObjects);
 
-            Vector2 newTopLeft = quad.TopLeft + delta;
+            Vector2 delta = Vector2.Zero;
-            if (newTopLeft.X < 0)
-                delta.X -= newTopLeft.X;
-            if (newTopLeft.Y < 0)
-                delta.Y -= newTopLeft.Y;
 
-            Vector2 newBottomRight = quad.BottomRight + delta;
+            if (quad.TopLeft.X < 0)
-            if (newBottomRight.X > DrawWidth)
+                delta.X -= quad.TopLeft.X;
-                delta.X -= newBottomRight.X - DrawWidth;
+            if (quad.TopLeft.Y < 0)
-            if (newBottomRight.Y > DrawHeight)
+                delta.Y -= quad.TopLeft.Y;
-                delta.Y -= newBottomRight.Y - DrawHeight;
+
+            if (quad.BottomRight.X > DrawWidth)
+                delta.X -= quad.BottomRight.X - DrawWidth;
+            if (quad.BottomRight.Y > DrawHeight)
+                delta.Y -= quad.BottomRight.Y - DrawHeight;
 
             foreach (var h in hitObjects)
                 h.Position += delta;
+        }
 
-            return true;
+        /// <summary>
+        /// Clamp scale for multi-object-scaling where selection does not exceed playfield bounds or flip.
+        /// </summary>
+        /// <param name="hitObjects">The hitobjects to be scaled</param>
+        /// <param name="reference">The anchor from which the scale operation is performed</param>
+        /// <param name="scale">The scale to be clamped</param>
+        /// <returns>The clamped scale vector</returns>
+        private Vector2 getClampedScale(OsuHitObject[] hitObjects, Anchor reference, Vector2 scale)
+        {
+            float xOffset = ((reference & Anchor.x0) > 0) ? -scale.X : 0;
+            float yOffset = ((reference & Anchor.y0) > 0) ? -scale.Y : 0;
+
+            Quad selectionQuad = getSurroundingQuad(hitObjects);
+
+            //todo: this is not always correct for selections involving sliders. This approximation assumes each point is scaled independently, but sliderends move with the sliderhead.
+            Quad scaledQuad = new Quad(selectionQuad.TopLeft.X + xOffset, selectionQuad.TopLeft.Y + yOffset, selectionQuad.Width + scale.X, selectionQuad.Height + scale.Y);
+
+            //max Size -> playfield bounds
+            if (scaledQuad.TopLeft.X < 0)
+                scale.X += scaledQuad.TopLeft.X;
+            if (scaledQuad.TopLeft.Y < 0)
+                scale.Y += scaledQuad.TopLeft.Y;
+
+            if (scaledQuad.BottomRight.X > DrawWidth)
+                scale.X -= scaledQuad.BottomRight.X - DrawWidth;
+            if (scaledQuad.BottomRight.Y > DrawHeight)
+                scale.Y -= scaledQuad.BottomRight.Y - DrawHeight;
+
+            //min Size -> almost 0. Less than 0 causes the quad to flip, exactly 0 causes scaling to get stuck at minimum scale.
+            Vector2 scaledSize = selectionQuad.Size + scale;
+            Vector2 minSize = new Vector2(Precision.FLOAT_EPSILON);
+
+            scale = Vector2.ComponentMax(minSize, scaledSize) - selectionQuad.Size;
+
+            return scale;
         }
 
         /// <summary>

osu.Game.Tournament.Tests/NonVisual/IPCLocationTest.cs

@@ -0,0 +1,73 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using osu.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Platform;
+using osu.Game.Tournament.IO;
+using osu.Game.Tournament.IPC;
+
+namespace osu.Game.Tournament.Tests.NonVisual
+{
+    [TestFixture]
+    public class IPCLocationTest
+    {
+        [Test]
+        public void CheckIPCLocation()
+        {
+            // don't use clean run because files are being written before osu! launches.
+            using (HeadlessGameHost host = new HeadlessGameHost(nameof(CheckIPCLocation)))
+            {
+                string basePath = Path.Combine(RuntimeInfo.StartupDirectory, "headless", nameof(CheckIPCLocation));
+
+                // Set up a fake IPC client for the IPC Storage to switch to.
+                string testStableInstallDirectory = Path.Combine(basePath, "stable-ce");
+                Directory.CreateDirectory(testStableInstallDirectory);
+
+                string ipcFile = Path.Combine(testStableInstallDirectory, "ipc.txt");
+                File.WriteAllText(ipcFile, string.Empty);
+
+                try
+                {
+                    var osu = loadOsu(host);
+                    TournamentStorage storage = (TournamentStorage)osu.Dependencies.Get<Storage>();
+                    FileBasedIPC ipc = null;
+
+                    waitForOrAssert(() => (ipc = osu.Dependencies.Get<MatchIPCInfo>() as FileBasedIPC) != null, @"ipc could not be populated in a reasonable amount of time");
+
+                    Assert.True(ipc.SetIPCLocation(testStableInstallDirectory));
+                    Assert.True(storage.AllTournaments.Exists("stable.json"));
+                }
+                finally
+                {
+                    host.Storage.DeleteDirectory(testStableInstallDirectory);
+                    host.Storage.DeleteDirectory("tournaments");
+                    host.Exit();
+                }
+            }
+        }
+
+        private TournamentGameBase loadOsu(GameHost host)
+        {
+            var osu = new TournamentGameBase();
+            Task.Run(() => host.Run(osu));
+            waitForOrAssert(() => osu.IsLoaded, @"osu! failed to start in a reasonable amount of time");
+            return osu;
+        }
+
+        private static void waitForOrAssert(Func<bool> result, string failureMessage, int timeout = 90000)
+        {
+            Task task = Task.Run(() =>
+            {
+                while (!result()) Thread.Sleep(200);
+            });
+
+            Assert.IsTrue(task.Wait(timeout), failureMessage);
+        }
+    }
+}

osu.Game.Tournament/IO/TournamentStorage.cs

@@ -1,12 +1,12 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Collections.Generic;
+using System.IO;
 using osu.Framework.Bindables;
 using osu.Framework.Logging;
 using osu.Framework.Platform;
 using osu.Game.IO;
-using System.IO;
-using System.Collections.Generic;
 using osu.Game.Tournament.Configuration;
 
 namespace osu.Game.Tournament.IO
@@ -15,7 +15,12 @@ namespace osu.Game.Tournament.IO
     {
         private const string default_tournament = "default";
         private readonly Storage storage;
-        private readonly Storage allTournaments;
+
+        /// <summary>
+        /// The storage where all tournaments are located.
+        /// </summary>
+        public readonly Storage AllTournaments;
+
         private readonly TournamentStorageManager storageConfig;
         public readonly Bindable<string> CurrentTournament;
 
@@ -23,16 +28,16 @@ namespace osu.Game.Tournament.IO
             : base(storage.GetStorageForDirectory("tournaments"), string.Empty)
         {
             this.storage = storage;
-            allTournaments = UnderlyingStorage;
+            AllTournaments = UnderlyingStorage;
 
             storageConfig = new TournamentStorageManager(storage);
 
             if (storage.Exists("tournament.ini"))
             {
-                ChangeTargetStorage(allTournaments.GetStorageForDirectory(storageConfig.Get<string>(StorageConfig.CurrentTournament)));
+                ChangeTargetStorage(AllTournaments.GetStorageForDirectory(storageConfig.Get<string>(StorageConfig.CurrentTournament)));
             }
             else
-                Migrate(allTournaments.GetStorageForDirectory(default_tournament));
+                Migrate(AllTournaments.GetStorageForDirectory(default_tournament));
 
             CurrentTournament = storageConfig.GetBindable<string>(StorageConfig.CurrentTournament);
             Logger.Log("Using tournament storage: " + GetFullPath(string.Empty));
@@ -42,11 +47,11 @@ namespace osu.Game.Tournament.IO
 
         private void updateTournament(ValueChangedEvent<string> newTournament)
         {
-            ChangeTargetStorage(allTournaments.GetStorageForDirectory(newTournament.NewValue));
+            ChangeTargetStorage(AllTournaments.GetStorageForDirectory(newTournament.NewValue));
             Logger.Log("Changing tournament storage: " + GetFullPath(string.Empty));
         }
 
-        public IEnumerable<string> ListTournaments() => allTournaments.GetDirectories(string.Empty);
+        public IEnumerable<string> ListTournaments() => AllTournaments.GetDirectories(string.Empty);
 
         public override void Migrate(Storage newStorage)
         {

osu.Game.Tournament/Models/StableInfo.cs

@@ -5,6 +5,7 @@ using System;
 using System.IO;
 using Newtonsoft.Json;
 using osu.Framework.Platform;
+using osu.Game.Tournament.IO;
 
 namespace osu.Game.Tournament.Models
 {
@@ -24,13 +25,14 @@ namespace osu.Game.Tournament.Models
         /// </summary>
         public event Action OnStableInfoSaved;
 
-        private const string config_path = "tournament/stable.json";
+        private const string config_path = "stable.json";
 
         private readonly Storage storage;
 
         public StableInfo(Storage storage)
         {
-            this.storage = storage;
+            TournamentStorage tStorage = (TournamentStorage)storage;
+            this.storage = tStorage.AllTournaments;
 
             if (!storage.Exists(config_path))
                 return;

osu.Game/Screens/Edit/Compose/Components/ComposeBlueprintContainer.cs

@@ -10,6 +10,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input;
+using osu.Framework.Input.Events;
 using osu.Game.Audio;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Rulesets.Edit;
@@ -19,6 +20,7 @@ using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Screens.Edit.Components.TernaryButtons;
 using osuTK;
+using osuTK.Input;
 
 namespace osu.Game.Screens.Edit.Compose.Components
 {
@@ -70,6 +72,50 @@ namespace osu.Game.Screens.Edit.Compose.Components
             }
         }
 
+        protected override bool OnKeyDown(KeyDownEvent e)
+        {
+            if (e.ControlPressed)
+            {
+                switch (e.Key)
+                {
+                    case Key.Left:
+                        moveSelection(new Vector2(-1, 0));
+                        return true;
+
+                    case Key.Right:
+                        moveSelection(new Vector2(1, 0));
+                        return true;
+
+                    case Key.Up:
+                        moveSelection(new Vector2(0, -1));
+                        return true;
+
+                    case Key.Down:
+                        moveSelection(new Vector2(0, 1));
+                        return true;
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Move the current selection spatially by the specified delta, in gamefield coordinates (ie. the same coordinates as the blueprints).
+        /// </summary>
+        /// <param name="delta"></param>
+        private void moveSelection(Vector2 delta)
+        {
+            var firstBlueprint = SelectionHandler.SelectedBlueprints.FirstOrDefault();
+
+            if (firstBlueprint == null)
+                return;
+
+            // convert to game space coordinates
+            delta = firstBlueprint.ToScreenSpace(delta) - firstBlueprint.ToScreenSpace(Vector2.Zero);
+
+            SelectionHandler.HandleMovement(new MoveSelectionEvent(firstBlueprint, firstBlueprint.ScreenSpaceSelectionPoint + delta));
+        }
+
         private void updatePlacementNewCombo()
         {
             if (currentPlacement?.HitObject is IHasComboInformation c)