Merge branch 'master' into placement-display-in-timeline

osu.Game.Rulesets.Osu.Tests/TestSceneLegacyBeatmapSkin.cs

@@ -89,7 +89,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             public IReadOnlyList<Color4> UsableComboColours =>
                 GameplayClockContainer.ChildrenOfType<BeatmapSkinProvidingContainer>()
                                       .First()
-                                      .GetConfig<GlobalSkinConfiguration, IReadOnlyList<Color4>>(GlobalSkinConfiguration.ComboColours)?.Value;
+                                      .GetConfig<GlobalSkinColours, IReadOnlyList<Color4>>(GlobalSkinColours.ComboColours)?.Value;
         }
 
         private class CustomSkinWorkingBeatmap : ClockBackedTestWorkingBeatmap

osu.Game.Rulesets.Osu/Edit/Blueprints/Spinners/SpinnerPlacementBlueprint.cs

@@ -1,6 +1,7 @@
 // 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 osu.Framework.Graphics;
 using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Edit;
@@ -8,6 +9,7 @@ using osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners.Components;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.UI;
 using osuTK;
+using osuTK.Input;
 
 namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners
 {
@@ -29,22 +31,31 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners
         {
             base.Update();
 
+            if (isPlacingEnd)
+                HitObject.EndTime = Math.Max(HitObject.StartTime, EditorClock.CurrentTime);
+
             piece.UpdateFrom(HitObject);
         }
 
-        protected override bool OnClick(ClickEvent e)
+        protected override bool OnMouseDown(MouseDownEvent e)
         {
             if (isPlacingEnd)
             {
+                if (e.Button != MouseButton.Right)
+                    return false;
+
                 HitObject.EndTime = EditorClock.CurrentTime;
                 EndPlacement(true);
             }
             else
             {
-                isPlacingEnd = true;
+                if (e.Button != MouseButton.Left)
-                piece.FadeTo(1f, 150, Easing.OutQuint);
+                    return false;
 
                 BeginPlacement();
+                piece.FadeTo(1f, 150, Easing.OutQuint);
+
+                isPlacingEnd = true;
             }
 
             return true;

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

@@ -36,6 +36,9 @@ namespace osu.Game.Rulesets.Osu.Edit
 
         protected override DistanceSnapGrid CreateDistanceSnapGrid(IEnumerable<HitObject> selectedHitObjects)
         {
+            if (BlueprintContainer.CurrentTool is SpinnerCompositionTool)
+                return null;
+
             var objects = selectedHitObjects.ToList();
 
             if (objects.Count == 0)
@@ -89,6 +92,9 @@ namespace osu.Game.Rulesets.Osu.Edit
                 targetIndex++;
             }
 
+            if (sourceObject is Spinner)
+                return null;
+
             return new OsuDistanceSnapGrid((OsuHitObject)sourceObject, (OsuHitObject)targetObject);
         }
     }

osu.Game.Rulesets.Osu/Objects/Spinner.cs

@@ -13,8 +13,13 @@ namespace osu.Game.Rulesets.Osu.Objects
 {
     public class Spinner : OsuHitObject, IHasEndTime
     {
-        public double EndTime { get; set; }
+        public double EndTime
-        public double Duration => EndTime - StartTime;
+        {
+            get => StartTime + Duration;
+            set => Duration = value - StartTime;
+        }
+
+        public double Duration { get; set; }
 
         /// <summary>
         /// Number of spins required to finish the spinner without miss.

osu.Game.Rulesets.Osu/Skinning/OsuLegacySkinTransformer.cs

@@ -46,17 +46,20 @@ namespace osu.Game.Rulesets.Osu.Skinning
             switch (osuComponent.Component)
             {
                 case OsuSkinComponents.FollowPoint:
-                    return this.GetAnimation(component.LookupName, true, false);
+                    return this.GetAnimation(component.LookupName, true, false, true);
 
                 case OsuSkinComponents.SliderFollowCircle:
-                    var followCircle = this.GetAnimation("sliderfollowcircle", true, true);
+                    var followCircle = this.GetAnimation("sliderfollowcircle", true, true, true);
                     if (followCircle != null)
                         // follow circles are 2x the hitcircle resolution in legacy skins (since they are scaled down from >1x
                         followCircle.Scale *= 0.5f;
                     return followCircle;
 
                 case OsuSkinComponents.SliderBall:
-                    var sliderBallContent = this.GetAnimation("sliderb", true, true, "");
+                    var sliderBallContent = this.GetAnimation("sliderb", true, true, animationSeparator: "");
+
+                    // todo: slider ball has a custom frame delay based on velocity
+                    // Math.Max((150 / Velocity) * GameBase.SIXTY_FRAME_TIME, GameBase.SIXTY_FRAME_TIME);
 
                     if (sliderBallContent != null)
                     {

osu.Game.Tests/Gameplay/TestSceneHitObjectAccentColour.cs

@@ -126,10 +126,10 @@ namespace osu.Game.Tests.Gameplay
             {
                 switch (lookup)
                 {
-                    case GlobalSkinConfiguration global:
+                    case GlobalSkinColours global:
                         switch (global)
                         {
-                            case GlobalSkinConfiguration.ComboColours:
+                            case GlobalSkinColours.ComboColours:
                                 return SkinUtils.As<TValue>(new Bindable<IReadOnlyList<Color4>>(ComboColours));
                         }
 

osu.Game.Tests/Skins/TestSceneSkinConfigurationLookup.cs

@@ -95,7 +95,7 @@ namespace osu.Game.Tests.Skins
         [Test]
         public void TestGlobalLookup()
         {
-            AddAssert("Check combo colours", () => requester.GetConfig<GlobalSkinConfiguration, IReadOnlyList<Color4>>(GlobalSkinConfiguration.ComboColours)?.Value?.Count > 0);
+            AddAssert("Check combo colours", () => requester.GetConfig<GlobalSkinColours, IReadOnlyList<Color4>>(GlobalSkinColours.ComboColours)?.Value?.Count > 0);
         }
 
         [Test]
@@ -121,7 +121,7 @@ namespace osu.Game.Tests.Skins
         public void TestEmptyComboColours()
         {
             AddAssert("Check retrieved combo colours is skin default colours", () =>
-                requester.GetConfig<GlobalSkinConfiguration, IReadOnlyList<Color4>>(GlobalSkinConfiguration.ComboColours)?.Value?.SequenceEqual(SkinConfiguration.DefaultComboColours) ?? false);
+                requester.GetConfig<GlobalSkinColours, IReadOnlyList<Color4>>(GlobalSkinColours.ComboColours)?.Value?.SequenceEqual(SkinConfiguration.DefaultComboColours) ?? false);
         }
 
         [Test]
@@ -136,7 +136,7 @@ namespace osu.Game.Tests.Skins
             AddStep("Disallow default colours fallback in source2", () => source2.Configuration.AllowDefaultComboColoursFallback = false);
 
             AddAssert("Check retrieved combo colours from source1", () =>
-                requester.GetConfig<GlobalSkinConfiguration, IReadOnlyList<Color4>>(GlobalSkinConfiguration.ComboColours)?.Value?.SequenceEqual(source1.Configuration.ComboColours) ?? false);
+                requester.GetConfig<GlobalSkinColours, IReadOnlyList<Color4>>(GlobalSkinColours.ComboColours)?.Value?.SequenceEqual(source1.Configuration.ComboColours) ?? false);
         }
 
         [Test]

osu.Game/Graphics/ScreenshotManager.cs

@@ -9,7 +9,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Audio;
 using osu.Framework.Audio.Sample;
 using osu.Framework.Bindables;
-using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics;
 using osu.Framework.Input;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Platform;
@@ -22,7 +22,7 @@ using SixLabors.ImageSharp;
 
 namespace osu.Game.Graphics
 {
-    public class ScreenshotManager : Container, IKeyBindingHandler<GlobalAction>, IHandleGlobalKeyboardInput
+    public class ScreenshotManager : Component, IKeyBindingHandler<GlobalAction>, IHandleGlobalKeyboardInput
     {
         private readonly BindableBool cursorVisibility = new BindableBool(true);
 

osu.Game/Rulesets/Edit/HitObjectComposer.cs

@@ -49,8 +49,9 @@ namespace osu.Game.Rulesets.Edit
         [Resolved]
         private IBeatSnapProvider beatSnapProvider { get; set; }
 
+        protected ComposeBlueprintContainer BlueprintContainer { get; private set; }
+
         private DrawableEditRulesetWrapper<TObject> drawableRulesetWrapper;
-        private ComposeBlueprintContainer blueprintContainer;
         private Container distanceSnapGridContainer;
         private DistanceSnapGrid distanceSnapGrid;
         private readonly List<Container> layerContainers = new List<Container>();
@@ -94,7 +95,7 @@ namespace osu.Game.Rulesets.Edit
                 new EditorPlayfieldBorder { RelativeSizeAxes = Axes.Both }
             });
 
-            var layerAboveRuleset = drawableRulesetWrapper.CreatePlayfieldAdjustmentContainer().WithChild(blueprintContainer = CreateBlueprintContainer());
+            var layerAboveRuleset = drawableRulesetWrapper.CreatePlayfieldAdjustmentContainer().WithChild(BlueprintContainer = CreateBlueprintContainer());
 
             layerContainers.Add(layerBelowRuleset);
             layerContainers.Add(layerAboveRuleset);
@@ -142,7 +143,7 @@ namespace osu.Game.Rulesets.Edit
 
             setSelectTool();
 
-            blueprintContainer.SelectionChanged += selectionChanged;
+            BlueprintContainer.SelectionChanged += selectionChanged;
         }
 
         protected override bool OnKeyDown(KeyDownEvent e)
@@ -174,7 +175,7 @@ namespace osu.Game.Rulesets.Edit
         {
             base.Update();
 
-            if (EditorClock.CurrentTime != lastGridUpdateTime && !(blueprintContainer.CurrentTool is SelectTool))
+            if (EditorClock.CurrentTime != lastGridUpdateTime && !(BlueprintContainer.CurrentTool is SelectTool))
                 showGridFor(Enumerable.Empty<HitObject>());
         }
 
@@ -210,7 +211,7 @@ namespace osu.Game.Rulesets.Edit
 
         private void toolSelected(HitObjectCompositionTool tool)
         {
-            blueprintContainer.CurrentTool = tool;
+            BlueprintContainer.CurrentTool = tool;
 
             if (tool is SelectTool)
                 distanceSnapGridContainer.Hide();

osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs

@@ -349,7 +349,7 @@ namespace osu.Game.Rulesets.Objects.Drawables
         {
             if (HitObject is IHasComboInformation combo)
             {
-                var comboColours = CurrentSkin.GetConfig<GlobalSkinConfiguration, IReadOnlyList<Color4>>(GlobalSkinConfiguration.ComboColours)?.Value;
+                var comboColours = CurrentSkin.GetConfig<GlobalSkinColours, IReadOnlyList<Color4>>(GlobalSkinColours.ComboColours)?.Value;
                 AccentColour.Value = comboColours?.Count > 0 ? comboColours[combo.ComboIndex % comboColours.Count] : Color4.White;
             }
         }

osu.Game/Screens/Edit/EditorScreenWithTimeline.cs

@@ -18,6 +18,8 @@ namespace osu.Game.Screens.Edit
         private const float vertical_margins = 10;
         private const float horizontal_margins = 20;
 
+        private const float timeline_height = 110;
+
         private readonly BindableBeatDivisor beatDivisor = new BindableBeatDivisor();
 
         private Container timelineContainer;
@@ -32,65 +34,57 @@ namespace osu.Game.Screens.Edit
 
             Children = new Drawable[]
             {
-                new GridContainer
+                mainContent = new Container
                 {
+                    Name = "Main content",
                     RelativeSizeAxes = Axes.Both,
-                    Content = new[]
+                    Padding = new MarginPadding
                     {
-                        new Drawable[]
+                        Horizontal = horizontal_margins,
+                        Top = vertical_margins + timeline_height,
+                        Bottom = vertical_margins
+                    },
+                },
+                new Container
+                {
+                    Name = "Timeline",
+                    RelativeSizeAxes = Axes.X,
+                    Height = timeline_height,
+                    Children = new Drawable[]
+                    {
+                        new Box
                         {
-                            new Container
+                            RelativeSizeAxes = Axes.Both,
+                            Colour = Color4.Black.Opacity(0.5f)
+                        },
+                        new Container
+                        {
+                            Name = "Timeline content",
+                            RelativeSizeAxes = Axes.Both,
+                            Padding = new MarginPadding { Horizontal = horizontal_margins, Vertical = vertical_margins },
+                            Child = new GridContainer
                             {
-                                Name = "Timeline",
                                 RelativeSizeAxes = Axes.Both,
-                                Children = new Drawable[]
+                                Content = new[]
                                 {
-                                    new Box
+                                    new Drawable[]
                                     {
-                                        RelativeSizeAxes = Axes.Both,
+                                        timelineContainer = new Container
-                                        Colour = Color4.Black.Opacity(0.5f)
-                                    },
-                                    new Container
-                                    {
-                                        Name = "Timeline content",
-                                        RelativeSizeAxes = Axes.Both,
-                                        Padding = new MarginPadding { Horizontal = horizontal_margins, Vertical = vertical_margins },
-                                        Child = new GridContainer
                                         {
                                             RelativeSizeAxes = Axes.Both,
-                                            Content = new[]
+                                            Padding = new MarginPadding { Right = 5 },
-                                            {
-                                                new Drawable[]
-                                                {
-                                                    timelineContainer = new Container
-                                                    {
-                                                        RelativeSizeAxes = Axes.Both,
-                                                        Padding = new MarginPadding { Right = 5 },
-                                                    },
-                                                    new BeatDivisorControl(beatDivisor) { RelativeSizeAxes = Axes.Both }
-                                                },
-                                            },
-                                            ColumnDimensions = new[]
-                                            {
-                                                new Dimension(),
-                                                new Dimension(GridSizeMode.Absolute, 90),
-                                            }
                                         },
-                                    }
+                                        new BeatDivisorControl(beatDivisor) { RelativeSizeAxes = Axes.Both }
+                                    },
+                                },
+                                ColumnDimensions = new[]
+                                {
+                                    new Dimension(),
+                                    new Dimension(GridSizeMode.Absolute, 90),
                                 }
-                            }
+                            },
-                        },
-                        new Drawable[]
-                        {
-                            mainContent = new Container
-                            {
-                                Name = "Main content",
-                                RelativeSizeAxes = Axes.Both,
-                                Padding = new MarginPadding { Horizontal = horizontal_margins, Vertical = vertical_margins },
-                            }
                         }
-                    },
+                    }
-                    RowDimensions = new[] { new Dimension(GridSizeMode.Absolute, 110) }
                 },
             };
 

osu.Game/Screens/Menu/LogoVisualisation.cs

@@ -123,7 +123,7 @@ namespace osu.Game.Screens.Menu
             Color4 defaultColour = Color4.White.Opacity(0.2f);
 
             if (user.Value?.IsSupporter ?? false)
-                AccentColour = skin.Value.GetConfig<GlobalSkinColour, Color4>(GlobalSkinColour.MenuGlow)?.Value ?? defaultColour;
+                AccentColour = skin.Value.GetConfig<GlobalSkinColours, Color4>(GlobalSkinColours.MenuGlow)?.Value ?? defaultColour;
             else
                 AccentColour = defaultColour;
         }

osu.Game/Screens/Menu/MenuSideFlashes.cs

@@ -112,7 +112,7 @@ namespace osu.Game.Screens.Menu
             Color4 baseColour = colours.Blue;
 
             if (user.Value?.IsSupporter ?? false)
-                baseColour = skin.Value.GetConfig<GlobalSkinColour, Color4>(GlobalSkinColour.MenuGlow)?.Value ?? baseColour;
+                baseColour = skin.Value.GetConfig<GlobalSkinColours, Color4>(GlobalSkinColours.MenuGlow)?.Value ?? baseColour;
 
             // linear colour looks better in this case, so let's use it for now.
             Color4 gradientDark = baseColour.Opacity(0).ToLinear();

osu.Game/Screens/Play/GameplayClockContainer.cs

@@ -78,7 +78,7 @@ namespace osu.Game.Screens.Play
 
             // Lazer's audio timings in general doesn't match stable. This is the result of user testing, albeit limited.
             // This only seems to be required on windows. We need to eventually figure out why, with a bit of luck.
-            platformOffsetClock = new FramedOffsetClock(adjustableClock) { Offset = RuntimeInfo.OS == RuntimeInfo.Platform.Windows ? 22 : 0 };
+            platformOffsetClock = new FramedOffsetClock(adjustableClock) { Offset = RuntimeInfo.OS == RuntimeInfo.Platform.Windows ? 15 : 0 };
 
             // the final usable gameplay clock with user-set offsets applied.
             userOffsetClock = new FramedOffsetClock(platformOffsetClock);

osu.Game/Skinning/DefaultSkin.cs

@@ -31,10 +31,10 @@ namespace osu.Game.Skinning
             {
                 // todo: this code is pulled from LegacySkin and should not exist.
                 // will likely change based on how databased storage of skin configuration goes.
-                case GlobalSkinConfiguration global:
+                case GlobalSkinColours global:
                     switch (global)
                     {
-                        case GlobalSkinConfiguration.ComboColours:
+                        case GlobalSkinColours.ComboColours:
                             return SkinUtils.As<TValue>(new Bindable<IReadOnlyList<Color4>>(Configuration.ComboColours));
                     }
 

osu.Game/Skinning/GlobalSkinColours.cs

@@ -3,8 +3,9 @@
 
 namespace osu.Game.Skinning
 {
-    public enum GlobalSkinColour
+    public enum GlobalSkinColours
     {
+        ComboColours,
         MenuGlow
     }
 }

osu.Game/Skinning/GlobalSkinConfiguration.cs

@@ -5,6 +5,6 @@ namespace osu.Game.Skinning
 {
     public enum GlobalSkinConfiguration
     {
-        ComboColours
+        AnimationFramerate
     }
 }

osu.Game/Skinning/LegacySkin.cs

@@ -68,22 +68,22 @@ namespace osu.Game.Skinning
         {
             switch (lookup)
             {
-                case GlobalSkinConfiguration global:
+                case GlobalSkinColours colour:
-                    switch (global)
+                    switch (colour)
                     {
-                        case GlobalSkinConfiguration.ComboColours:
+                        case GlobalSkinColours.ComboColours:
                             var comboColours = Configuration.ComboColours;
                             if (comboColours != null)
                                 return SkinUtils.As<TValue>(new Bindable<IReadOnlyList<Color4>>(comboColours));
 
                             break;
+
+                        default:
+                            return SkinUtils.As<TValue>(getCustomColour(colour.ToString()));
                     }
 
                     break;
 
-                case GlobalSkinColour colour:
-                    return SkinUtils.As<TValue>(getCustomColour(colour.ToString()));
-
                 case LegacySkinConfiguration.LegacySetting legacy:
                     switch (legacy)
                     {
@@ -100,6 +100,8 @@ namespace osu.Game.Skinning
                     return SkinUtils.As<TValue>(getCustomColour(customColour.Lookup.ToString()));
 
                 default:
+                    // handles lookups like GlobalSkinConfiguration
+
                     try
                     {
                         if (Configuration.ConfigDictionary.TryGetValue(lookup.ToString(), out var val))

osu.Game/Skinning/LegacySkinExtensions.cs

@@ -1,6 +1,8 @@
 // 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.Linq;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Animations;
 using osu.Framework.Graphics.Sprites;
@@ -10,48 +12,62 @@ namespace osu.Game.Skinning
 {
     public static class LegacySkinExtensions
     {
-        public static Drawable GetAnimation(this ISkin source, string componentName, bool animatable, bool looping, string animationSeparator = "-")
+        public static Drawable GetAnimation(this ISkin source, string componentName, bool animatable, bool looping, bool applyConfigFrameRate = false, string animationSeparator = "-")
         {
-            const double default_frame_time = 1000 / 60d;
-
             Texture texture;
 
-            Texture getFrameTexture(int frame) => source.GetTexture($"{componentName}{animationSeparator}{frame}");
-
-            TextureAnimation animation = null;
-
             if (animatable)
             {
-                for (int i = 0; true; i++)
+                var textures = getTextures().ToArray();
+
+                if (textures.Length > 0)
                 {
-                    if ((texture = getFrameTexture(i)) == null)
+                    var animation = new TextureAnimation
-                        break;
-
-                    if (animation == null)
                     {
-                        animation = new TextureAnimation
+                        DefaultFrameLength = getFrameLength(source, applyConfigFrameRate, textures),
-                        {
+                        Repeat = looping,
-                            DefaultFrameLength = default_frame_time,
+                    };
-                            Repeat = looping
-                        };
-                    }
 
-                    animation.AddFrame(texture);
+                    foreach (var t in textures)
+                        animation.AddFrame(t);
+
+                    return animation;
                 }
             }
 
-            if (animation != null)
+            // if an animation was not allowed or not found, fall back to a sprite retrieval.
-                return animation;
-
             if ((texture = source.GetTexture(componentName)) != null)
-            {
+                return new Sprite { Texture = texture };
-                return new Sprite
-                {
-                    Texture = texture
-                };
-            }
 
             return null;
+
+            IEnumerable<Texture> getTextures()
+            {
+                for (int i = 0; true; i++)
+                {
+                    if ((texture = source.GetTexture($"{componentName}{animationSeparator}{i}")) == null)
+                        break;
+
+                    yield return texture;
+                }
+            }
+        }
+
+        private const double default_frame_time = 1000 / 60d;
+
+        private static double getFrameLength(ISkin source, bool applyConfigFrameRate, Texture[] textures)
+        {
+            if (applyConfigFrameRate)
+            {
+                var iniRate = source.GetConfig<GlobalSkinConfiguration, int>(GlobalSkinConfiguration.AnimationFramerate);
+
+                if (iniRate != null)
+                    return 1000f / iniRate.Value;
+
+                return 1000f / textures.Length;
+            }
+
+            return default_frame_time;
         }
     }
 }

osu.Game/Tests/Visual/EditorTestScene.cs

@@ -24,8 +24,13 @@ namespace osu.Game.Tests.Visual
         private void load()
         {
             Beatmap.Value = CreateWorkingBeatmap(ruleset.RulesetInfo);
+        }
 
-            LoadScreen(new Editor());
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            AddStep("Load editor", () => LoadScreen(new Editor()));
         }
     }
 }