Merge branch 'master' into applicable-to-dho

osu.Game.Rulesets.Osu/Mods/OsuModApproachDifferent.cs

@@ -0,0 +1,102 @@
+// 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 osu.Framework.Bindables;
+using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Configuration;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+
+namespace osu.Game.Rulesets.Osu.Mods
+{
+    public class OsuModApproachDifferent : Mod, IApplicableToDrawableHitObjects
+    {
+        public override string Name => "Approach Different";
+        public override string Acronym => "AD";
+        public override string Description => "Never trust the approach circles...";
+        public override double ScoreMultiplier => 1;
+        public override IconUsage? Icon { get; } = FontAwesome.Regular.Circle;
+
+        [SettingSource("Initial size", "Change the initial size of the approach circle, relative to hit circles.", 0)]
+        public BindableFloat Scale { get; } = new BindableFloat(4)
+        {
+            Precision = 0.1f,
+            MinValue = 2,
+            MaxValue = 10,
+        };
+
+        [SettingSource("Style", "Change the animation style of the approach circles.", 1)]
+        public Bindable<AnimationStyle> Style { get; } = new Bindable<AnimationStyle>();
+
+        public void ApplyToDrawableHitObjects(IEnumerable<DrawableHitObject> drawables)
+        {
+            drawables.ForEach(drawable =>
+            {
+                drawable.ApplyCustomUpdateState += (drawableObject, state) =>
+                {
+                    if (!(drawableObject is DrawableHitCircle drawableHitCircle)) return;
+
+                    var hitCircle = drawableHitCircle.HitObject;
+
+                    drawableHitCircle.ApproachCircle.ClearTransforms(targetMember: nameof(Scale));
+
+                    using (drawableHitCircle.BeginAbsoluteSequence(hitCircle.StartTime - hitCircle.TimePreempt))
+                        drawableHitCircle.ApproachCircle.ScaleTo(Scale.Value).ScaleTo(1f, hitCircle.TimePreempt, getEasing(Style.Value));
+                };
+            });
+        }
+
+        private Easing getEasing(AnimationStyle style)
+        {
+            switch (style)
+            {
+                default:
+                    return Easing.None;
+
+                case AnimationStyle.Accelerate1:
+                    return Easing.In;
+
+                case AnimationStyle.Accelerate2:
+                    return Easing.InCubic;
+
+                case AnimationStyle.Accelerate3:
+                    return Easing.InQuint;
+
+                case AnimationStyle.Gravity:
+                    return Easing.InBack;
+
+                case AnimationStyle.Decelerate1:
+                    return Easing.Out;
+
+                case AnimationStyle.Decelerate2:
+                    return Easing.OutCubic;
+
+                case AnimationStyle.Decelerate3:
+                    return Easing.OutQuint;
+
+                case AnimationStyle.InOut1:
+                    return Easing.InOutCubic;
+
+                case AnimationStyle.InOut2:
+                    return Easing.InOutQuint;
+            }
+        }
+
+        public enum AnimationStyle
+        {
+            Gravity,
+            InOut1,
+            InOut2,
+            Accelerate1,
+            Accelerate2,
+            Accelerate3,
+            Decelerate1,
+            Decelerate2,
+            Decelerate3,
+        }
+    }
+}

osu.Game.Rulesets.Osu/OsuRuleset.cs

@@ -187,6 +187,7 @@ namespace osu.Game.Rulesets.Osu
                         new MultiMod(new ModWindUp(), new ModWindDown()),
                         new OsuModTraceable(),
                         new OsuModBarrelRoll(),
+                        new OsuModApproachDifferent(),
                     };
 
                 case ModType.System:

osu.Game/Extensions/LanguageExtensions.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 System;
+using System.Globalization;
+using osu.Game.Localisation;
+
+namespace osu.Game.Extensions
+{
+    /// <summary>
+    /// Conversion utilities for the <see cref="Language"/> enum.
+    /// </summary>
+    public static class LanguageExtensions
+    {
+        /// <summary>
+        /// Returns the culture code of the <see cref="CultureInfo"/> that corresponds to the supplied <paramref name="language"/>.
+        /// </summary>
+        /// <remarks>
+        /// This is required as enum member names are not allowed to contain hyphens.
+        /// </remarks>
+        public static string ToCultureCode(this Language language)
+            => language.ToString().Replace("_", "-");
+
+        /// <summary>
+        /// Attempts to parse the supplied <paramref name="cultureCode"/> to a <see cref="Language"/> value.
+        /// </summary>
+        /// <param name="cultureCode">The code of the culture to parse.</param>
+        /// <param name="language">The parsed <see cref="Language"/>. Valid only if the return value of the method is <see langword="true" />.</param>
+        /// <returns>Whether the parsing succeeded.</returns>
+        public static bool TryParseCultureCode(string cultureCode, out Language language)
+            => Enum.TryParse(cultureCode.Replace("-", "_"), out language);
+    }
+}

osu.Game/Localisation/Language.cs

@@ -10,7 +10,104 @@ namespace osu.Game.Localisation
         [Description(@"English")]
         en,
 
+        // TODO: Requires Arabic glyphs to be added to resources (and possibly also RTL support).
+        // [Description(@"اَلْعَرَبِيَّةُ")]
+        // ar,
+
+        // TODO: Some accented glyphs are missing. Revisit when adding Inter.
+        // [Description(@"Беларуская мова")]
+        // be,
+
+        [Description(@"Български")]
+        bg,
+
+        [Description(@"Česky")]
+        cs,
+
+        [Description(@"Dansk")]
+        da,
+
+        [Description(@"Deutsch")]
+        de,
+
+        // TODO: Some accented glyphs are missing. Revisit when adding Inter.
+        // [Description(@"Ελληνικά")]
+        // el,
+
+        [Description(@"español")]
+        es,
+
+        [Description(@"Suomi")]
+        fi,
+
+        [Description(@"français")]
+        fr,
+
+        [Description(@"Magyar")]
+        hu,
+
+        [Description(@"Bahasa Indonesia")]
+        id,
+
+        [Description(@"Italiano")]
+        it,
+
         [Description(@"日本語")]
-        ja
+        ja,
+
+        [Description(@"한국어")]
+        ko,
+
+        [Description(@"Nederlands")]
+        nl,
+
+        [Description(@"Norsk")]
+        no,
+
+        [Description(@"polski")]
+        pl,
+
+        [Description(@"Português")]
+        pt,
+
+        [Description(@"Português (Brasil)")]
+        pt_br,
+
+        [Description(@"Română")]
+        ro,
+
+        [Description(@"Русский")]
+        ru,
+
+        [Description(@"Slovenčina")]
+        sk,
+
+        [Description(@"Svenska")]
+        sv,
+
+        [Description(@"ไทย")]
+        th,
+
+        [Description(@"Tagalog")]
+        tl,
+
+        [Description(@"Türkçe")]
+        tr,
+
+        // TODO: Some accented glyphs are missing. Revisit when adding Inter.
+        // [Description(@"Українська мова")]
+        // uk,
+
+        [Description(@"Tiếng Việt")]
+        vi,
+
+        [Description(@"简体中文")]
+        zh,
+
+        [Description(@"繁體中文（香港）")]
+        zh_hk,
+
+        [Description(@"繁體中文（台灣）")]
+        zh_tw
     }
 }

osu.Game/OsuGame.cs

@@ -50,8 +50,10 @@ using osu.Game.Updater;
 using osu.Game.Utils;
 using LogLevel = osu.Framework.Logging.LogLevel;
 using osu.Game.Database;
+using osu.Game.Extensions;
 using osu.Game.IO;
 using osu.Game.Localisation;
+using osu.Game.Performance;
 using osu.Game.Skinning.Editor;
 
 namespace osu.Game
@@ -487,6 +489,8 @@ namespace osu.Game
 
         protected virtual UpdateManager CreateUpdateManager() => new UpdateManager();
 
+        protected virtual HighPerformanceSession CreateHighPerformanceSession() => new HighPerformanceSession();
+
         protected override Container CreateScalingContainer() => new ScalingContainer(ScalingMode.Everything);
 
         #region Beatmap progression
@@ -580,7 +584,7 @@ namespace osu.Game
 
             foreach (var language in Enum.GetValues(typeof(Language)).OfType<Language>())
             {
-                var cultureCode = language.ToString();
+                var cultureCode = language.ToCultureCode();
                 Localisation.AddLanguage(cultureCode, new ResourceManagerLocalisationStore(cultureCode));
             }
 
@@ -755,6 +759,8 @@ namespace osu.Game
             loadComponentSingleFile(new AccountCreationOverlay(), topMostOverlayContent.Add, true);
             loadComponentSingleFile(new DialogOverlay(), topMostOverlayContent.Add, true);
 
+            loadComponentSingleFile(CreateHighPerformanceSession(), Add);
+
             chatOverlay.State.ValueChanged += state => channelManager.HighPollRate.Value = state.NewValue == Visibility.Visible;
 
             Add(difficultyRecommender);

osu.Game/Overlays/OverlaySortTabControl.cs

@@ -18,6 +18,7 @@ using JetBrains.Annotations;
 using System;
 using osu.Framework.Extensions;
 using osu.Framework.Localisation;
+using osu.Game.Resources.Localisation.Web;
 
 namespace osu.Game.Overlays
 {
@@ -54,7 +55,7 @@ namespace osu.Game.Overlays
                         Anchor = Anchor.CentreLeft,
                         Origin = Anchor.CentreLeft,
                         Font = OsuFont.GetFont(size: 12, weight: FontWeight.SemiBold),
-                        Text = @"Sort by"
+                        Text = SortStrings.Default
                     },
                     CreateControl().With(c =>
                     {

osu.Game/Overlays/Settings/Sections/General/LanguageSettings.cs

@@ -1,11 +1,11 @@
 // 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.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Configuration;
 using osu.Framework.Graphics;
+using osu.Game.Extensions;
 using osu.Game.Localisation;
 
 namespace osu.Game.Overlays.Settings.Sections.General
@@ -35,11 +35,11 @@ namespace osu.Game.Overlays.Settings.Sections.General
                 },
             };
 
-            if (!Enum.TryParse<Language>(frameworkLocale.Value, out var locale))
+            if (!LanguageExtensions.TryParseCultureCode(frameworkLocale.Value, out var locale))
                 locale = Language.en;
             languageSelection.Current.Value = locale;
 
-            languageSelection.Current.BindValueChanged(val => frameworkLocale.Value = val.NewValue.ToString());
+            languageSelection.Current.BindValueChanged(val => frameworkLocale.Value = val.NewValue.ToCultureCode());
         }
     }
 }

osu.Game/Overlays/Settings/SettingsEnumDropdown.cs

@@ -19,6 +19,8 @@ namespace osu.Game.Overlays.Settings
                 Margin = new MarginPadding { Top = 5 };
                 RelativeSizeAxes = Axes.X;
             }
+
+            protected override DropdownMenu CreateMenu() => base.CreateMenu().With(m => m.MaxHeight = 200);
         }
     }
 }

osu.Game/Performance/HighPerformanceSession.cs

@@ -0,0 +1,47 @@
+// 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.Runtime;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+
+namespace osu.Game.Performance
+{
+    public class HighPerformanceSession : Component
+    {
+        private readonly IBindable<bool> localUserPlaying = new Bindable<bool>();
+        private GCLatencyMode originalGCMode;
+
+        [BackgroundDependencyLoader]
+        private void load(OsuGame game)
+        {
+            localUserPlaying.BindTo(game.LocalUserPlaying);
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            localUserPlaying.BindValueChanged(playing =>
+            {
+                if (playing.NewValue)
+                    EnableHighPerformanceSession();
+                else
+                    DisableHighPerformanceSession();
+            }, true);
+        }
+
+        protected virtual void EnableHighPerformanceSession()
+        {
+            originalGCMode = GCSettings.LatencyMode;
+            GCSettings.LatencyMode = GCLatencyMode.LowLatency;
+        }
+
+        protected virtual void DisableHighPerformanceSession()
+        {
+            if (GCSettings.LatencyMode == GCLatencyMode.LowLatency)
+                GCSettings.LatencyMode = originalGCMode;
+        }
+    }
+}

osu.Game/Rulesets/UI/Scrolling/ScrollingHitObjectContainer.cs

@@ -69,7 +69,7 @@ namespace osu.Game.Rulesets.UI.Scrolling
         /// </remarks>
         public double TimeAtPosition(float localPosition, double currentTime)
         {
-            float scrollPosition = axisInverted ? scrollLength - localPosition : localPosition;
+            float scrollPosition = axisInverted ? -localPosition : localPosition;
             return scrollingInfo.Algorithm.TimeAt(scrollPosition, currentTime, timeRange.Value, scrollLength);
         }
 
@@ -81,8 +81,10 @@ namespace osu.Game.Rulesets.UI.Scrolling
         /// </remarks>
         public double TimeAtScreenSpacePosition(Vector2 screenSpacePosition)
         {
-            Vector2 localPosition = ToLocalSpace(screenSpacePosition);
-            return TimeAtPosition(scrollingAxis == Direction.Horizontal ? localPosition.X : localPosition.Y, Time.Current);
+            Vector2 pos = ToLocalSpace(screenSpacePosition);
+            float localPosition = scrollingAxis == Direction.Horizontal ? pos.X : pos.Y;
+            localPosition -= axisInverted ? scrollLength : 0;
+            return TimeAtPosition(localPosition, Time.Current);
         }
 
         /// <summary>
@@ -91,7 +93,7 @@ namespace osu.Game.Rulesets.UI.Scrolling
         public float PositionAtTime(double time, double currentTime)
         {
             float scrollPosition = scrollingInfo.Algorithm.PositionAt(time, currentTime, timeRange.Value, scrollLength);
-            return axisInverted ? scrollLength - scrollPosition : scrollPosition;
+            return axisInverted ? -scrollPosition : scrollPosition;
         }
 
         /// <summary>
@@ -106,6 +108,7 @@ namespace osu.Game.Rulesets.UI.Scrolling
         public Vector2 ScreenSpacePositionAtTime(double time)
         {
             float localPosition = PositionAtTime(time, Time.Current);
+            localPosition += axisInverted ? scrollLength : 0;
             return scrollingAxis == Direction.Horizontal
                 ? ToScreenSpace(new Vector2(localPosition, DrawHeight / 2))
                 : ToScreenSpace(new Vector2(DrawWidth / 2, localPosition));
@@ -236,14 +239,10 @@ namespace osu.Game.Rulesets.UI.Scrolling
         {
             float position = PositionAtTime(hitObject.HitObject.StartTime, currentTime);
 
-            // The position returned from `PositionAtTime` is assuming the `TopLeft` anchor.
-            // A correction is needed because the hit objects are using a different anchor for each direction (e.g. `BottomCentre` for `Bottom` direction).
-            float anchorCorrection = axisInverted ? scrollLength : 0;
-
             if (scrollingAxis == Direction.Horizontal)
-                hitObject.X = position - anchorCorrection;
+                hitObject.X = position;
             else
-                hitObject.Y = position - anchorCorrection;
+                hitObject.Y = position;
         }
     }
 }

osu.Game/Skinning/SkinnableTargetContainer.cs

@@ -18,6 +18,8 @@ namespace osu.Game.Skinning
 
         private readonly BindableList<ISkinnableDrawable> components = new BindableList<ISkinnableDrawable>();
 
+        public bool ComponentsLoaded { get; private set; }
+
         public SkinnableTargetContainer(SkinnableTarget target)
         {
             Target = target;
@@ -30,6 +32,7 @@ namespace osu.Game.Skinning
         {
             ClearInternal();
             components.Clear();
+            ComponentsLoaded = false;
 
             content = CurrentSkin.GetDrawableComponent(new SkinnableTargetComponent(Target)) as SkinnableTargetComponentsContainer;
 
@@ -39,8 +42,11 @@ namespace osu.Game.Skinning
                 {
                     AddInternal(wrapper);
                     components.AddRange(wrapper.Children.OfType<ISkinnableDrawable>());
+                    ComponentsLoaded = true;
                 });
             }
+            else
+                ComponentsLoaded = true;
         }
 
         /// <inheritdoc cref="ISkinnableTarget"/>

osu.Game/Tests/Visual/LegacySkinPlayerTestScene.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.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Extensions.IEnumerableExtensions;
@@ -47,6 +48,8 @@ namespace osu.Game.Tests.Visual
                 LegacySkin.ResetDrawableTarget(t);
                 t.Reload();
             }));
+
+            AddUntilStep("wait for components to load", () => this.ChildrenOfType<SkinnableTargetContainer>().All(t => t.ComponentsLoaded));
         }
 
         public class SkinProvidingPlayer : TestPlayer

osu.Game/Tests/Visual/OsuTestScene.cs

@@ -350,7 +350,7 @@ namespace osu.Game.Tests.Visual
                     if (CurrentTime >= Length)
                     {
                         Stop();
-                        RaiseCompleted();
+                        // `RaiseCompleted` is not called here to prevent transitioning to the next song.
                     }
                 }
             }