Merge remote-tracking branch 'origin/master' into taiko-visual-update

osu-framework

@@ -1 +1 @@
-Subproject commit 71177efb0c416361e4b346a92dd61ab20bf333d0
+Subproject commit 777996fb9731ba1895a5ab1323cbbc97259ff741

osu-resources

@@ -1 +1 @@
-Subproject commit ffccbeb98dc9e8f0965520270b5885e63f244c83
+Subproject commit 9f46a456dc3a56dcbff09671a3f588b16a464106

osu.Desktop.VisualTests/Tests/TestCaseManiaPlayfield.cs

@@ -41,7 +41,7 @@ namespace osu.Desktop.VisualTests.Tests
                 Clear();
 
                 ManiaPlayfield playField;
-                Add(playField = new ManiaPlayfield(cols, new List<TimingChange>())
+                Add(playField = new ManiaPlayfield(cols, new List<TimingChange> { new TimingChange { BeatLength = 200 } })
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,

osu.Desktop/Beatmaps/IO/LegacyFilesystemReader.cs

@@ -37,5 +37,7 @@ namespace osu.Desktop.Beatmaps.IO
         {
             // no-op
         }
+
+        public override Stream GetUnderlyingStream() => null;
     }
 }

osu.Game.Rulesets.Mania/Objects/Drawables/DrawableNote.cs

@@ -1,10 +1,13 @@
 // 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 OpenTK.Graphics;
 using OpenTK.Input;
 using osu.Framework.Configuration;
 using osu.Framework.Graphics;
+using osu.Framework.Input;
+using osu.Game.Rulesets.Mania.Judgements;
 using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
 using osu.Game.Rulesets.Objects.Drawables;
 
@@ -40,14 +43,53 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             }
         }
 
-        protected override void Update()
+        protected override void CheckJudgement(bool userTriggered)
         {
-            if (Time.Current > HitObject.StartTime)
+            if (!userTriggered)
-                Colour = Color4.Green;
+            {
+                if (Judgement.TimeOffset > HitObject.HitWindows.Bad / 2)
+                    Judgement.Result = HitResult.Miss;
+                return;
+            }
+
+            double offset = Math.Abs(Judgement.TimeOffset);
+
+            if (offset > HitObject.HitWindows.Miss / 2)
+                return;
+
+            ManiaHitResult? tmpResult = HitObject.HitWindows.ResultFor(offset);
+
+            if (tmpResult.HasValue)
+            {
+                Judgement.Result = HitResult.Hit;
+                Judgement.ManiaResult = tmpResult.Value;
+            }
+            else
+                Judgement.Result = HitResult.Miss;
         }
 
         protected override void UpdateState(ArmedState state)
         {
+            switch (State)
+            {
+                case ArmedState.Hit:
+                    Colour = Color4.Green;
+                    break;
+            }
+        }
+
+        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
+        {
+            if (Judgement.Result != HitResult.None)
+                return false;
+
+            if (args.Key != Key)
+                return false;
+
+            if (args.Repeat)
+                return false;
+
+            return UpdateJudgement(true);
         }
     }
 }

osu.Game.Rulesets.Mania/Timing/ControlPointContainer.cs

@@ -26,7 +26,7 @@ namespace osu.Game.Rulesets.Mania.Timing
         /// </summary>
         public double TimeSpan { get; set; }
 
-        private readonly List<DrawableControlPoint> drawableControlPoints = new List<DrawableControlPoint>();
+        private readonly List<DrawableControlPoint> drawableControlPoints;
 
         public ControlPointContainer(IEnumerable<TimingChange> timingChanges)
         {

osu.Game.Rulesets.Mania/Timing/TimingChange.cs

@@ -1,23 +1,23 @@
-// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
+
-namespace osu.Game.Rulesets.Mania.Timing
+namespace osu.Game.Rulesets.Mania.Timing
-{
+{
-    public class TimingChange
+    public class TimingChange
-    {
+    {
-        /// <summary>
+        /// <summary>
-        /// The time at which this timing change happened.
+        /// The time at which this timing change happened.
-        /// </summary>
+        /// </summary>
-        public double Time;
+        public double Time;
-
+
-        /// <summary>
+        /// <summary>
-        /// The beat length.
+        /// The beat length.
-        /// </summary>
+        /// </summary>
-        public double BeatLength = 500;
+        public double BeatLength = 500;
-
+
-        /// <summary>
+        /// <summary>
-        /// The speed multiplier.
+        /// The speed multiplier.
-        /// </summary>
+        /// </summary>
-        public double SpeedMultiplier = 1;
+        public double SpeedMultiplier = 1;
-    }
+    }
 }

osu.Game.Rulesets.Taiko/Objects/TaikoHitObject.cs

@@ -31,12 +31,12 @@ namespace osu.Game.Rulesets.Taiko.Objects
         public const float DEFAULT_STRONG_CIRCLE_DIAMETER = DEFAULT_CIRCLE_DIAMETER * STRONG_CIRCLE_DIAMETER_SCALE;
 
         /// <summary>
-        /// The time taken from the initial (off-screen) spawn position to the centre of the hit target for a <see cref="ControlPoint.BeatLength"/> of 1000ms.
+        /// The time taken from the initial (off-screen) spawn position to the centre of the hit target for a <see cref="TimingControlPoint.BeatLength"/> of 1000ms.
         /// </summary>
         private const double scroll_time = 6000;
 
         /// <summary>
-        /// Our adjusted <see cref="scroll_time"/> taking into consideration local <see cref="ControlPoint.BeatLength"/> and other speed multipliers.
+        /// Our adjusted <see cref="scroll_time"/> taking into consideration local <see cref="TimingControlPoint.BeatLength"/> and other speed multipliers.
         /// </summary>
         public double ScrollTime;
 

osu.Game/Beatmaps/ControlPoints/ControlPointInfo.cs

@@ -55,7 +55,7 @@ namespace osu.Game.Beatmaps.ControlPoints
         /// </summary>
         /// <param name="time">The time to find the timing control point at.</param>
         /// <returns>The timing control point.</returns>
-        public TimingControlPoint TimingPointAt(double time) => binarySearch(TimingPoints, time);
+        public TimingControlPoint TimingPointAt(double time) => binarySearch(TimingPoints, time, TimingPoints.FirstOrDefault());
 
         /// <summary>
         /// Finds the maximum BPM represented by any timing control point.
@@ -75,14 +75,21 @@ namespace osu.Game.Beatmaps.ControlPoints
         public double BPMMode =>
             60000 / (TimingPoints.GroupBy(c => c.BeatLength).OrderByDescending(grp => grp.Count()).FirstOrDefault()?.FirstOrDefault() ?? new TimingControlPoint()).BeatLength;
 
-        private T binarySearch<T>(SortedList<T> list, double time)
+        /// <summary>
+        /// Binary searches one of the control point lists to find the active control point at <paramref name="time"/>.
+        /// </summary>
+        /// <param name="list">The list to search.</param>
+        /// <param name="time">The time to find the control point at.</param>
+        /// <param name="prePoint">The control point to use when <paramref name="time"/> is before any control points. If null, a new control point will be constructed.</param>
+        /// <returns>The active control point at <paramref name="time"/>.</returns>
+        private T binarySearch<T>(SortedList<T> list, double time, T prePoint = null)
             where T : ControlPoint, new()
         {
             if (list.Count == 0)
                 return new T();
 
             if (time < list[0].Time)
-                return new T();
+                return prePoint ?? new T();
 
             int index = list.BinarySearch(new T() { Time = time });
 
@@ -92,8 +99,8 @@ namespace osu.Game.Beatmaps.ControlPoints
 
             index = ~index;
 
-            if (index == list.Count)
+            // BinarySearch will return the index of the first element _greater_ than the search
-                return list[list.Count - 1];
+            // This is the inactive point - the active point is the one before it (index - 1)
             return list[index - 1];
         }
     }

osu.Game/Beatmaps/IO/ArchiveReader.cs

@@ -63,5 +63,7 @@ namespace osu.Game.Beatmaps.IO
                 return buffer;
             }
         }
+
+        public abstract Stream GetUnderlyingStream();
     }
 }

osu.Game/Beatmaps/IO/OszArchiveReader.cs

@@ -49,5 +49,7 @@ namespace osu.Game.Beatmaps.IO
             archive.Dispose();
             archiveStream.Dispose();
         }
+
+        public override Stream GetUnderlyingStream() => archiveStream;
     }
 }

osu.Game/Database/BeatmapDatabase.cs

@@ -12,6 +12,7 @@ using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Formats;
 using osu.Game.Beatmaps.IO;
 using osu.Game.IPC;
+using osu.Game.Screens.Menu;
 using SQLite.Net;
 using SQLiteNetExtensions.Extensions;
 
@@ -38,6 +39,10 @@ namespace osu.Game.Database
         {
             foreach (var b in GetAllWithChildren<BeatmapSetInfo>(b => b.DeletePending))
             {
+                if (b.Hash == Intro.MENU_MUSIC_BEATMAP_HASH)
+                    // this is a bit hacky, but will do for now.
+                    continue;
+
                 try
                 {
                     Storage.Delete(b.Path);
@@ -97,50 +102,49 @@ namespace osu.Game.Database
             typeof(BeatmapDifficulty),
         };
 
+        public void Import(string path)
+        {
+            try
+            {
+                Import(ArchiveReader.GetReader(Storage, path));
+
+                // We may or may not want to delete the file depending on where it is stored.
+                //  e.g. reconstructing/repairing database with beatmaps from default storage.
+                // Also, not always a single file, i.e. for LegacyFilesystemReader
+                // TODO: Add a check to prevent files from storage to be deleted.
+                try
+                {
+                    File.Delete(path);
+                }
+                catch (Exception e)
+                {
+                    Logger.Error(e, $@"Could not delete file at {path}");
+                }
+            }
+            catch (Exception e)
+            {
+                e = e.InnerException ?? e;
+                Logger.Error(e, @"Could not import beatmap set");
+            }
+        }
+
+        public void Import(ArchiveReader archiveReader)
+        {
+            BeatmapSetInfo set = getBeatmapSet(archiveReader);
+
+            //If we have an ID then we already exist in the database.
+            if (set.ID == 0)
+                Import(new[] { set });
+        }
+
         /// <summary>
         /// Import multiple <see cref="BeatmapSetInfo"/> from <paramref name="paths"/>.
         /// </summary>
         /// <param name="paths">Multiple locations on disk</param>
-        public void Import(IEnumerable<string> paths)
+        public void Import(params string[] paths)
         {
             foreach (string p in paths)
-            {
+                Import(p);
-                try
-                {
-                    BeatmapSetInfo set = getBeatmapSet(p);
-
-                    //If we have an ID then we already exist in the database.
-                    if (set.ID == 0)
-                        Import(new[] { set });
-
-                    // We may or may not want to delete the file depending on where it is stored.
-                    //  e.g. reconstructing/repairing database with beatmaps from default storage.
-                    // Also, not always a single file, i.e. for LegacyFilesystemReader
-                    // TODO: Add a check to prevent files from storage to be deleted.
-                    try
-                    {
-                        File.Delete(p);
-                    }
-                    catch (Exception e)
-                    {
-                        Logger.Error(e, $@"Could not delete file at {p}");
-                    }
-                }
-                catch (Exception e)
-                {
-                    e = e.InnerException ?? e;
-                    Logger.Error(e, @"Could not import beatmap set");
-                }
-            }
-        }
-
-        /// <summary>
-        /// Import <see cref="BeatmapSetInfo"/> from <paramref name="path"/>.
-        /// </summary>
-        /// <param name="path">Location on disk</param>
-        public void Import(string path)
-        {
-            Import(new[] { path });
         }
 
         /// <summary>
@@ -148,29 +152,26 @@ namespace osu.Game.Database
         /// </summary>
         /// <param name="path">Content location</param>
         /// <returns><see cref="BeatmapSetInfo"/></returns>
-        private BeatmapSetInfo getBeatmapSet(string path)
+        private BeatmapSetInfo getBeatmapSet(string path) => getBeatmapSet(ArchiveReader.GetReader(Storage, path));
-        {
-            string hash = null;
 
+        private BeatmapSetInfo getBeatmapSet(ArchiveReader archiveReader)
+        {
             BeatmapMetadata metadata;
 
-            using (var reader = ArchiveReader.GetReader(Storage, path))
+            using (var stream = new StreamReader(archiveReader.GetStream(archiveReader.BeatmapFilenames[0])))
-            {
+                metadata = BeatmapDecoder.GetDecoder(stream).Decode(stream).Metadata;
-                using (var stream = new StreamReader(reader.GetStream(reader.BeatmapFilenames[0])))
-                    metadata = BeatmapDecoder.GetDecoder(stream).Decode(stream).Metadata;
-            }
 
-            if (File.Exists(path)) // Not always the case, i.e. for LegacyFilesystemReader
+            string hash;
+            string path;
+
+            using (var input = archiveReader.GetUnderlyingStream())
             {
-                using (var input = Storage.GetStream(path))
+                hash = input.GetMd5Hash();
-                {
+                input.Seek(0, SeekOrigin.Begin);
-                    hash = input.GetMd5Hash();
+                path = Path.Combine(@"beatmaps", hash.Remove(1), hash.Remove(2), hash);
-                    input.Seek(0, SeekOrigin.Begin);
+                if (!Storage.Exists(path))
-                    path = Path.Combine(@"beatmaps", hash.Remove(1), hash.Remove(2), hash);
+                    using (var output = Storage.GetStream(path, FileAccess.Write))
-                    if (!Storage.Exists(path))
+                        input.CopyTo(output);
-                        using (var output = Storage.GetStream(path, FileAccess.Write))
-                            input.CopyTo(output);
-                }
             }
 
             var existing = Connection.Table<BeatmapSetInfo>().FirstOrDefault(b => b.Hash == hash);

osu.Game/Graphics/Containers/BeatSyncedContainer.cs

@@ -12,20 +12,26 @@ namespace osu.Game.Graphics.Containers
 {
     public class BeatSyncedContainer : Container
     {
-        private readonly Bindable<WorkingBeatmap> beatmap = new Bindable<WorkingBeatmap>();
+        protected readonly Bindable<WorkingBeatmap> Beatmap = new Bindable<WorkingBeatmap>();
 
         private int lastBeat;
         private TimingControlPoint lastTimingPoint;
 
+        /// <summary>
+        /// The amount of time before a beat we should fire <see cref="OnNewBeat(int, TimingControlPoint, EffectControlPoint, TrackAmplitudes)"/>.
+        /// This allows for adding easing to animations that may be synchronised to the beat.
+        /// </summary>
+        protected double EarlyActivationMilliseconds;
+
         protected override void Update()
         {
-            if (beatmap.Value?.Track == null)
+            if (Beatmap.Value?.Track == null)
                 return;
 
-            double currentTrackTime = beatmap.Value.Track.CurrentTime;
+            double currentTrackTime = Beatmap.Value.Track.CurrentTime + EarlyActivationMilliseconds;
 
-            TimingControlPoint timingPoint = beatmap.Value.Beatmap.ControlPointInfo.TimingPointAt(currentTrackTime);
+            TimingControlPoint timingPoint = Beatmap.Value.Beatmap.ControlPointInfo.TimingPointAt(currentTrackTime);
-            EffectControlPoint effectPoint = beatmap.Value.Beatmap.ControlPointInfo.EffectPointAt(currentTrackTime);
+            EffectControlPoint effectPoint = Beatmap.Value.Beatmap.ControlPointInfo.EffectPointAt(currentTrackTime);
 
             if (timingPoint.BeatLength == 0)
                 return;
@@ -42,7 +48,7 @@ namespace osu.Game.Graphics.Containers
             double offsetFromBeat = (timingPoint.Time - currentTrackTime) % timingPoint.BeatLength;
 
             using (BeginDelayedSequence(offsetFromBeat, true))
-                OnNewBeat(beatIndex, timingPoint, effectPoint, beatmap.Value.Track.CurrentAmplitudes);
+                OnNewBeat(beatIndex, timingPoint, effectPoint, Beatmap.Value.Track.CurrentAmplitudes);
 
             lastBeat = beatIndex;
             lastTimingPoint = timingPoint;
@@ -51,7 +57,7 @@ namespace osu.Game.Graphics.Containers
         [BackgroundDependencyLoader]
         private void load(OsuGameBase game)
         {
-            beatmap.BindTo(game.Beatmap);
+            Beatmap.BindTo(game.Beatmap);
         }
 
         protected virtual void OnNewBeat(int beatIndex, TimingControlPoint timingPoint, EffectControlPoint effectPoint, TrackAmplitudes amplitudes)

osu.Game/OsuGame.cs

@@ -82,7 +82,7 @@ namespace osu.Game
             if (args?.Length > 0)
             {
                 var paths = args.Where(a => !a.StartsWith(@"-"));
-                Task.Run(() => BeatmapDatabase.Import(paths));
+                Task.Run(() => BeatmapDatabase.Import(paths.ToArray()));
             }
 
             Dependencies.Cache(this);

osu.Game/Overlays/Settings/Sections/Graphics/LayoutSettings.cs

@@ -4,6 +4,7 @@
 using osu.Framework.Allocation;
 using osu.Framework.Configuration;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
 
 namespace osu.Game.Overlays.Settings.Sections.Graphics
 {
@@ -11,11 +12,12 @@ namespace osu.Game.Overlays.Settings.Sections.Graphics
     {
         protected override string Header => "Layout";
 
-        private SettingsSlider<double> letterboxPositionX;
+        private FillFlowContainer letterboxSettings;
-        private SettingsSlider<double> letterboxPositionY;
 
         private Bindable<bool> letterboxing;
 
+        private const int transition_duration = 400;
+
         [BackgroundDependencyLoader]
         private void load(FrameworkConfigManager config)
         {
@@ -33,34 +35,40 @@ namespace osu.Game.Overlays.Settings.Sections.Graphics
                     LabelText = "Letterboxing",
                     Bindable = letterboxing,
                 },
-                letterboxPositionX = new SettingsSlider<double>
+                letterboxSettings = new FillFlowContainer
                 {
-                    LabelText = "Horizontal position",
+                    Direction = FillDirection.Vertical,
-                    Bindable = config.GetBindable<double>(FrameworkSetting.LetterboxPositionX)
+                    RelativeSizeAxes = Axes.X,
-                },
+                    AutoSizeAxes = Axes.Y,
-                letterboxPositionY = new SettingsSlider<double>
+                    AutoSizeDuration = transition_duration,
-                {
+                    AutoSizeEasing = EasingTypes.OutQuint,
-                    LabelText = "Vertical position",
+                    Masking = true,
-                    Bindable = config.GetBindable<double>(FrameworkSetting.LetterboxPositionY)
+
+                    Children = new Drawable[]
+                    {
+                        new SettingsSlider<double>
+                        {
+                            LabelText = "Horizontal position",
+                            Bindable = config.GetBindable<double>(FrameworkSetting.LetterboxPositionX)
+                        },
+                        new SettingsSlider<double>
+                        {
+                            LabelText = "Vertical position",
+                            Bindable = config.GetBindable<double>(FrameworkSetting.LetterboxPositionY)
+                        },
+                    }
                 },
             };
 
-            letterboxing.ValueChanged += visibilityChanged;
+            letterboxing.ValueChanged += isVisible =>
-            letterboxing.TriggerChange();
+            {
-        }
+                letterboxSettings.ClearTransforms();
+                letterboxSettings.AutoSizeAxes = isVisible ? Axes.Y : Axes.None;
 
-        private void visibilityChanged(bool newVisibility)
+                if(!isVisible)
-        {
+                    letterboxSettings.ResizeHeightTo(0, transition_duration, EasingTypes.OutQuint);
-            if (newVisibility)
+            };
-            {
+            letterboxing.TriggerChange();
-                letterboxPositionX.Show();
-                letterboxPositionY.Show();
-            }
-            else
-            {
-                letterboxPositionX.Hide();
-                letterboxPositionY.Hide();
-            }
         }
     }
 }

osu.Game/Screens/Menu/Intro.cs

@@ -8,7 +8,10 @@ using osu.Framework.Audio.Track;
 using osu.Framework.Configuration;
 using osu.Framework.Screens;
 using osu.Framework.Graphics;
+using osu.Framework.MathUtils;
+using osu.Game.Beatmaps.IO;
 using osu.Game.Configuration;
+using osu.Game.Database;
 using osu.Game.Graphics.Containers;
 using osu.Game.Screens.Backgrounds;
 using OpenTK.Graphics;
@@ -19,6 +22,8 @@ namespace osu.Game.Screens.Menu
     {
         private readonly OsuLogo logo;
 
+        public const string MENU_MUSIC_BEATMAP_HASH = "21c1271b91234385978b5418881fdd88";
+
         /// <summary>
         /// Whether we have loaded the menu previously.
         /// </summary>
@@ -27,7 +32,6 @@ namespace osu.Game.Screens.Menu
         private MainMenu mainMenu;
         private SampleChannel welcome;
         private SampleChannel seeya;
-        private Track bgm;
 
         internal override bool HasLocalCursorDisplayed => true;
 
@@ -60,15 +64,49 @@ namespace osu.Game.Screens.Menu
 
         private Bindable<bool> menuVoice;
         private Bindable<bool> menuMusic;
+        private Track track;
 
         [BackgroundDependencyLoader]
-        private void load(AudioManager audio, OsuConfigManager config)
+        private void load(AudioManager audio, OsuConfigManager config, BeatmapDatabase beatmaps, Framework.Game game)
         {
             menuVoice = config.GetBindable<bool>(OsuSetting.MenuVoice);
             menuMusic = config.GetBindable<bool>(OsuSetting.MenuMusic);
 
-            bgm = audio.Track.Get(@"circles");
+            var trackManager = audio.Track;
-            bgm.Looping = true;
+
+            BeatmapSetInfo setInfo = null;
+
+            if (!menuMusic)
+            {
+                var query = beatmaps.Query<BeatmapSetInfo>().Where(b => !b.DeletePending);
+                int count = query.Count();
+                if (count > 0)
+                    setInfo = query.ElementAt(RNG.Next(0, count - 1));
+            }
+
+            if (setInfo == null)
+            {
+                var query = beatmaps.Query<BeatmapSetInfo>().Where(b => b.Hash == MENU_MUSIC_BEATMAP_HASH);
+
+                setInfo = query.FirstOrDefault();
+
+                if (setInfo == null)
+                {
+                    // we need to import the default menu background beatmap
+                    beatmaps.Import(new OszArchiveReader(game.Resources.GetStream(@"Tracks/circles.osz")));
+
+                    setInfo = query.First();
+
+                    setInfo.DeletePending = true;
+                    beatmaps.Update(setInfo, false);
+                }
+            }
+
+            beatmaps.GetChildren(setInfo);
+            Beatmap = beatmaps.GetWorkingBeatmap(setInfo.Beatmaps[0]);
+
+            track = Beatmap.Track;
+            trackManager.SetExclusive(track);
 
             welcome = audio.Sample.Get(@"welcome");
             seeya = audio.Sample.Get(@"seeya");
@@ -83,8 +121,7 @@ namespace osu.Game.Screens.Menu
 
             Scheduler.AddDelayed(delegate
             {
-                if (menuMusic)
+                track.Start();
-                    bgm.Start();
 
                 LoadComponentAsync(mainMenu = new MainMenu());
 

osu.Game/Screens/Menu/MainMenu.cs

@@ -1,18 +1,12 @@
 // 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.Threading.Tasks;
 using OpenTK;
 using OpenTK.Input;
 using osu.Framework.Allocation;
-using osu.Framework.Audio.Track;
-using osu.Framework.Configuration;
 using osu.Framework.Graphics;
 using osu.Framework.Input;
-using osu.Framework.MathUtils;
 using osu.Framework.Screens;
-using osu.Game.Configuration;
-using osu.Game.Database;
 using osu.Game.Graphics.Containers;
 using osu.Game.Screens.Backgrounds;
 using osu.Game.Screens.Charts;
@@ -54,36 +48,18 @@ namespace osu.Game.Screens.Menu
                             OnSolo = delegate { Push(consumeSongSelect()); },
                             OnMulti = delegate { Push(new Lobby()); },
                             OnExit = delegate { Exit(); },
-                        }
+                        },
+                        new MenuSideFlashes(),
                     }
                 }
             };
         }
 
-        private Bindable<bool> menuMusic;
-        private TrackManager trackManager;
-
         [BackgroundDependencyLoader]
-        private void load(OsuGame game, OsuConfigManager config, BeatmapDatabase beatmaps)
+        private void load(OsuGame game)
         {
-            menuMusic = config.GetBindable<bool>(OsuSetting.MenuMusic);
             LoadComponentAsync(background);
 
-            if (!menuMusic)
-            {
-                trackManager = game.Audio.Track;
-
-                var query = beatmaps.Query<BeatmapSetInfo>().Where(b => !b.DeletePending);
-                int count = query.Count();
-
-                if (count > 0)
-                {
-                    var beatmap = query.ElementAt(RNG.Next(0, count - 1));
-                    beatmaps.GetChildren(beatmap);
-                    Beatmap = beatmaps.GetWorkingBeatmap(beatmap.Beatmaps[0]);
-                }
-            }
-
             buttons.OnSettings = game.ToggleSettings;
 
             preloadSongSelect();
@@ -108,14 +84,13 @@ namespace osu.Game.Screens.Menu
             buttons.FadeInFromZero(500);
             if (last is Intro && Beatmap != null)
             {
-                Task.Run(() =>
+                if (!Beatmap.Track.IsRunning)
                 {
-                    trackManager.SetExclusive(Beatmap.Track);
                     Beatmap.Track.Seek(Beatmap.Metadata.PreviewTime);
                     if (Beatmap.Metadata.PreviewTime == -1)
                         Beatmap.Track.Seek(Beatmap.Track.Length * 0.4f);
                     Beatmap.Track.Start();
-                });
+                }
             }
         }
 

osu.Game/Screens/Menu/MenuSideFlashes.cs

@@ -0,0 +1,96 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using OpenTK.Graphics;
+using osu.Framework.Allocation;
+using osu.Framework.Audio.Track;
+using osu.Framework.Configuration;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Colour;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Containers;
+using System;
+
+namespace osu.Game.Screens.Menu
+{
+    public class MenuSideFlashes : BeatSyncedContainer
+    {
+        public override bool HandleInput => false;
+
+        private readonly Bindable<WorkingBeatmap> beatmap = new Bindable<WorkingBeatmap>();
+
+        private readonly Box leftBox;
+        private readonly Box rightBox;
+
+        private const float amplitude_dead_zone = 0.25f;
+        private const float alpha_multiplier = (1 - amplitude_dead_zone) / 0.55f;
+        private const float kiai_multiplier = (1 - amplitude_dead_zone * 0.95f) / 0.8f;
+
+        private const int box_max_alpha = 200;
+        private const double box_fade_in_time = 65;
+        private const int box_width = 200;
+
+        public MenuSideFlashes()
+        {
+            RelativeSizeAxes = Axes.Both;
+            Anchor = Anchor.Centre;
+            Origin = Anchor.Centre;
+            Children = new Drawable[]
+            {
+                leftBox = new Box
+                {
+                    Anchor = Anchor.CentreLeft,
+                    Origin = Anchor.CentreLeft,
+                    RelativeSizeAxes = Axes.Y,
+                    Width = box_width,
+                    Alpha = 0,
+                    BlendingMode = BlendingMode.Additive,
+                },
+                rightBox = new Box
+                {
+                    Anchor = Anchor.CentreRight,
+                    Origin = Anchor.CentreRight,
+                    RelativeSizeAxes = Axes.Y,
+                    Width = box_width,
+                    Alpha = 0,
+                    BlendingMode = BlendingMode.Additive,
+                }
+            };
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuGameBase game, OsuColour colours)
+        {
+            beatmap.BindTo(game.Beatmap);
+
+            // linear colour looks better in this case, so let's use it for now.
+            Color4 gradientDark = colours.Blue.Opacity(0).ToLinear();
+            Color4 gradientLight = colours.Blue.Opacity(0.3f).ToLinear();
+
+            leftBox.ColourInfo = ColourInfo.GradientHorizontal(gradientLight, gradientDark);
+            rightBox.ColourInfo = ColourInfo.GradientHorizontal(gradientDark, gradientLight);
+        }
+
+        protected override void OnNewBeat(int beatIndex, TimingControlPoint timingPoint, EffectControlPoint effectPoint, TrackAmplitudes amplitudes)
+        {
+            if (beatIndex < 0)
+                return;
+
+            if (effectPoint.KiaiMode ? beatIndex % 2 == 0 : beatIndex % (int)timingPoint.TimeSignature == 0)
+                flash(leftBox, timingPoint.BeatLength, effectPoint.KiaiMode, amplitudes);
+            if (effectPoint.KiaiMode ? beatIndex % 2 == 1 : beatIndex % (int)timingPoint.TimeSignature == 0)
+                flash(rightBox, timingPoint.BeatLength, effectPoint.KiaiMode, amplitudes);
+        }
+
+        private void flash(Drawable d, double beatLength, bool kiai, TrackAmplitudes amplitudes)
+        {
+            d.FadeTo(Math.Max(0, ((d.Equals(leftBox) ? amplitudes.LeftChannel : amplitudes.RightChannel) - amplitude_dead_zone) / (kiai ? kiai_multiplier : alpha_multiplier)), box_fade_in_time);
+            using (d.BeginDelayedSequence(box_fade_in_time))
+                d.FadeOut(beatLength, EasingTypes.In);
+        }
+    }
+}

osu.Game/Screens/Menu/OsuLogo.cs

@@ -5,13 +5,16 @@ using System;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
 using osu.Framework.Audio.Sample;
+using osu.Framework.Audio.Track;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.Input;
+using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Backgrounds;
+using osu.Game.Graphics.Containers;
 using OpenTK;
 using OpenTK.Graphics;
 
@@ -20,13 +23,15 @@ namespace osu.Game.Screens.Menu
     /// <summary>
     /// osu! logo and its attachments (pulsing, visualiser etc.)
     /// </summary>
-    public class OsuLogo : Container
+    public class OsuLogo : BeatSyncedContainer
     {
         public readonly Color4 OsuPink = OsuColour.FromHex(@"e967a1");
 
         private readonly Sprite logo;
         private readonly CircularContainer logoContainer;
         private readonly Container logoBounceContainer;
+        private readonly Container logoBeatContainer;
+        private readonly Container logoAmplitudeContainer;
         private readonly Container logoHoverContainer;
 
         private SampleChannel sampleClick;
@@ -67,8 +72,12 @@ namespace osu.Game.Screens.Menu
 
         private const float default_size = 480;
 
+        private const double beat_in_time = 60;
+
         public OsuLogo()
         {
+            EarlyActivationMilliseconds = beat_in_time;
+
             Size = new Vector2(default_size);
 
             Anchor = Anchor.Centre;
@@ -78,67 +87,16 @@ namespace osu.Game.Screens.Menu
 
             Children = new Drawable[]
             {
-                logoBounceContainer = new Container
+                logoHoverContainer = new Container
                 {
                     AutoSizeAxes = Axes.Both,
                     Children = new Drawable[]
                     {
-                        logoHoverContainer = new Container
+                        logoBounceContainer = new Container
                         {
                             AutoSizeAxes = Axes.Both,
                             Children = new Drawable[]
                             {
-                                new BufferedContainer
-                                {
-                                    AutoSizeAxes = Axes.Both,
-                                    Children = new Drawable[]
-                                    {
-                                        logoContainer = new CircularContainer
-                                        {
-                                            Anchor = Anchor.Centre,
-                                            Origin = Anchor.Centre,
-                                            RelativeSizeAxes = Axes.Both,
-                                            Scale = new Vector2(0.88f),
-                                            Masking = true,
-                                            Children = new Drawable[]
-                                            {
-                                                colourAndTriangles = new Container
-                                                {
-                                                    RelativeSizeAxes = Axes.Both,
-                                                    Anchor = Anchor.Centre,
-                                                    Origin = Anchor.Centre,
-                                                    Children = new Drawable[]
-                                                    {
-                                                        new Box
-                                                        {
-                                                            RelativeSizeAxes = Axes.Both,
-                                                            Colour = OsuPink,
-                                                        },
-                                                        new Triangles
-                                                        {
-                                                            TriangleScale = 4,
-                                                            ColourLight = OsuColour.FromHex(@"ff7db7"),
-                                                            ColourDark = OsuColour.FromHex(@"de5b95"),
-                                                            RelativeSizeAxes = Axes.Both,
-                                                        },
-                                                    }
-                                                },
-                                                flashLayer = new Box
-                                                {
-                                                    RelativeSizeAxes = Axes.Both,
-                                                    BlendingMode = BlendingMode.Additive,
-                                                    Colour = Color4.White,
-                                                    Alpha = 0,
-                                                },
-                                            },
-                                        },
-                                        logo = new Sprite
-                                        {
-                                            Anchor = Anchor.Centre,
-                                            Origin = Anchor.Centre,
-                                        },
-                                    }
-                                },
                                 rippleContainer = new Container
                                 {
                                     Anchor = Anchor.Centre,
@@ -151,36 +109,101 @@ namespace osu.Game.Screens.Menu
                                             Anchor = Anchor.Centre,
                                             Origin = Anchor.Centre,
                                             BlendingMode = BlendingMode.Additive,
-                                            Alpha = 0.15f
+                                            Alpha = 0
                                         }
                                     }
                                 },
-                                impactContainer = new CircularContainer
+                                logoAmplitudeContainer = new Container
                                 {
-                                    Anchor = Anchor.Centre,
+                                    AutoSizeAxes = Axes.Both,
-                                    Origin = Anchor.Centre,
-                                    Alpha = 0,
-                                    BorderColour = Color4.White,
-                                    RelativeSizeAxes = Axes.Both,
-                                    BorderThickness = 10,
-                                    Masking = true,
                                     Children = new Drawable[]
                                     {
-                                        new Box
+                                        logoBeatContainer = new Container
                                         {
-                                            RelativeSizeAxes = Axes.Both,
+                                            AutoSizeAxes = Axes.Both,
-                                            AlwaysPresent = true,
+                                            Children = new Drawable[]
-                                            Alpha = 0,
+                                            {
+                                                new BufferedContainer
+                                                {
+                                                    AutoSizeAxes = Axes.Both,
+                                                    Children = new Drawable[]
+                                                    {
+                                                        logoContainer = new CircularContainer
+                                                        {
+                                                            Anchor = Anchor.Centre,
+                                                            Origin = Anchor.Centre,
+                                                            RelativeSizeAxes = Axes.Both,
+                                                            Scale = new Vector2(0.88f),
+                                                            Masking = true,
+                                                            Children = new Drawable[]
+                                                            {
+                                                                colourAndTriangles = new Container
+                                                                {
+                                                                    RelativeSizeAxes = Axes.Both,
+                                                                    Anchor = Anchor.Centre,
+                                                                    Origin = Anchor.Centre,
+                                                                    Children = new Drawable[]
+                                                                    {
+                                                                        new Box
+                                                                        {
+                                                                            RelativeSizeAxes = Axes.Both,
+                                                                            Colour = OsuPink,
+                                                                        },
+                                                                        new Triangles
+                                                                        {
+                                                                            TriangleScale = 4,
+                                                                            ColourLight = OsuColour.FromHex(@"ff7db7"),
+                                                                            ColourDark = OsuColour.FromHex(@"de5b95"),
+                                                                            RelativeSizeAxes = Axes.Both,
+                                                                        },
+                                                                    }
+                                                                },
+                                                                flashLayer = new Box
+                                                                {
+                                                                    RelativeSizeAxes = Axes.Both,
+                                                                    BlendingMode = BlendingMode.Additive,
+                                                                    Colour = Color4.White,
+                                                                    Alpha = 0,
+                                                                },
+                                                            },
+                                                        },
+                                                        logo = new Sprite
+                                                        {
+                                                            Anchor = Anchor.Centre,
+                                                            Origin = Anchor.Centre,
+                                                        },
+                                                    }
+                                                },
+                                                impactContainer = new CircularContainer
+                                                {
+                                                    Anchor = Anchor.Centre,
+                                                    Origin = Anchor.Centre,
+                                                    Alpha = 0,
+                                                    BorderColour = Color4.White,
+                                                    RelativeSizeAxes = Axes.Both,
+                                                    BorderThickness = 10,
+                                                    Masking = true,
+                                                    Children = new Drawable[]
+                                                    {
+                                                        new Box
+                                                        {
+                                                            RelativeSizeAxes = Axes.Both,
+                                                            AlwaysPresent = true,
+                                                            Alpha = 0,
+                                                        }
+                                                    }
+                                                },
+                                                new MenuVisualisation
+                                                {
+                                                    Anchor = Anchor.Centre,
+                                                    Origin = Anchor.Centre,
+                                                    RelativeSizeAxes = Axes.Both,
+                                                    BlendingMode = BlendingMode.Additive,
+                                                    Alpha = 0.2f,
+                                                }
+                                            }
                                         }
                                     }
-                                },
-                                new MenuVisualisation
-                                {
-                                    Anchor = Anchor.Centre,
-                                    Origin = Anchor.Centre,
-                                    RelativeSizeAxes = Axes.Both,
-                                    BlendingMode = BlendingMode.Additive,
-                                    Alpha = 0.2f,
                                 }
                             }
                         }
@@ -197,13 +220,48 @@ namespace osu.Game.Screens.Menu
             ripple.Texture = textures.Get(@"Menu/logo");
         }
 
-        protected override void LoadComplete()
+        private int lastBeatIndex;
-        {
-            base.LoadComplete();
 
-            ripple.ScaleTo(ripple.Scale * 1.1f, 500);
+        protected override void OnNewBeat(int beatIndex, TimingControlPoint timingPoint, EffectControlPoint effectPoint, TrackAmplitudes amplitudes)
-            ripple.FadeOut(500);
+        {
-            ripple.Loop(300);
+            base.OnNewBeat(beatIndex, timingPoint, effectPoint, amplitudes);
+
+            lastBeatIndex = beatIndex;
+
+            var beatLength = timingPoint.BeatLength;
+
+            float amplitudeAdjust = Math.Min(1, 0.4f + amplitudes.Maximum);
+
+            if (beatIndex < 0) return;
+
+            logoBeatContainer.ScaleTo(1 - 0.02f * amplitudeAdjust, beat_in_time, EasingTypes.Out);
+            using (logoBeatContainer.BeginDelayedSequence(beat_in_time))
+                logoBeatContainer.ScaleTo(1, beatLength * 2, EasingTypes.OutQuint);
+
+            ripple.ClearTransforms();
+
+            ripple.ScaleTo(logoAmplitudeContainer.Scale);
+            ripple.Alpha = 0.15f * amplitudeAdjust;
+
+            ripple.ScaleTo(logoAmplitudeContainer.Scale * (1 + 0.04f * amplitudeAdjust), beatLength, EasingTypes.OutQuint);
+            ripple.FadeOut(beatLength, EasingTypes.OutQuint);
+
+            if (effectPoint.KiaiMode && flashLayer.Alpha < 0.4f)
+            {
+                flashLayer.ClearTransforms();
+
+                flashLayer.FadeTo(0.2f * amplitudeAdjust, beat_in_time, EasingTypes.Out);
+                using (flashLayer.BeginDelayedSequence(beat_in_time))
+                    flashLayer.FadeOut(beatLength);
+            }
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            var maxAmplitude = lastBeatIndex >= 0 ? Beatmap.Value?.Track?.CurrentAmplitudes.Maximum ?? 0 : 0;
+            logoAmplitudeContainer.ScaleTo(1 - maxAmplitude * 0.04f, 50, EasingTypes.OutQuint);
         }
 
         protected override bool OnMouseDown(InputState state, MouseDownEventArgs args)
@@ -254,4 +312,4 @@ namespace osu.Game.Screens.Menu
             impactContainer.ScaleTo(1.12f, 250);
         }
     }
-}
+}

osu.Game/Screens/Play/HUDOverlay.cs

@@ -30,7 +30,6 @@ namespace osu.Game.Screens.Play
         public readonly SongProgress Progress;
         public readonly ModDisplay ModDisplay;
 
-        private Bindable<bool> showKeyCounter;
         private Bindable<bool> showHud;
 
         private static bool hasShownNotificationOnce;
@@ -67,24 +66,8 @@ namespace osu.Game.Screens.Play
         [BackgroundDependencyLoader(true)]
         private void load(OsuConfigManager config, NotificationManager notificationManager)
         {
-            showKeyCounter = config.GetBindable<bool>(OsuSetting.KeyOverlay);
-            showKeyCounter.ValueChanged += keyCounterVisibility =>
-            {
-                if (keyCounterVisibility)
-                    KeyCounter.FadeIn(duration);
-                else
-                    KeyCounter.FadeOut(duration);
-            };
-            showKeyCounter.TriggerChange();
-
             showHud = config.GetBindable<bool>(OsuSetting.ShowInterface);
-            showHud.ValueChanged += hudVisibility =>
+            showHud.ValueChanged += hudVisibility => content.FadeTo(hudVisibility ? 1 : 0, duration);
-            {
-                if (hudVisibility)
-                    content.FadeIn(duration);
-                else
-                    content.FadeOut(duration);
-            };
             showHud.TriggerChange();
 
             if (!showHud && !hasShownNotificationOnce)

osu.Game/Screens/Play/KeyCounterCollection.cs

@@ -6,11 +6,18 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using OpenTK.Graphics;
 using osu.Framework.Input;
+using osu.Framework.Configuration;
+using osu.Framework.Allocation;
+using osu.Game.Configuration;
 
 namespace osu.Game.Screens.Play
 {
     public class KeyCounterCollection : FillFlowContainer<KeyCounter>
     {
+        private const int duration = 100;
+
+        private Bindable<bool> showKeyCounter;
+
         public KeyCounterCollection()
         {
             AlwaysReceiveInput = true;
@@ -34,6 +41,14 @@ namespace osu.Game.Screens.Play
                 counter.ResetCount();
         }
 
+        [BackgroundDependencyLoader]
+        private void load(OsuConfigManager config)
+        {
+            showKeyCounter = config.GetBindable<bool>(OsuSetting.KeyOverlay);
+            showKeyCounter.ValueChanged += keyCounterVisibility => FadeTo(keyCounterVisibility ? 1 : 0, duration);
+            showKeyCounter.TriggerChange();
+        }
+
         //further: change default values here and in KeyCounter if needed, instead of passing them in every constructor
         private bool isCounting;
         public bool IsCounting

osu.Game/Screens/Select/BeatmapCarousel.cs

@@ -170,8 +170,8 @@ namespace osu.Game.Screens.Select
             List<BeatmapGroup> visibleGroups = groups.Where(selectGroup => selectGroup.State != BeatmapGroupState.Hidden).ToList();
             if (visibleGroups.Count < 1)
                 return;
-            BeatmapGroup group = visibleGroups[RNG.Next(visibleGroups.Count)];
 
+            BeatmapGroup group = visibleGroups[RNG.Next(visibleGroups.Count)];
             BeatmapPanel panel = group.BeatmapPanels[RNG.Next(group.BeatmapPanels.Count)];
 
             selectGroup(group, panel);

osu.Game/Screens/Select/SongSelect.cs

@@ -316,11 +316,12 @@ namespace osu.Game.Screens.Select
         /// </summary>
         private void selectionChanged(BeatmapInfo beatmap)
         {
-            bool beatmapSetChange = false;
+            selectionChangedDebounce?.Cancel();
 
             if (beatmap.Equals(Beatmap?.BeatmapInfo))
                 return;
 
+            bool beatmapSetChange = false;
             if (beatmap.BeatmapSetInfoID == selectionChangeNoBounce?.BeatmapSetInfoID)
                 sampleChangeDifficulty.Play();
             else
@@ -331,7 +332,6 @@ namespace osu.Game.Screens.Select
 
             selectionChangeNoBounce = beatmap;
 
-            selectionChangedDebounce?.Cancel();
             selectionChangedDebounce = Scheduler.AddDelayed(delegate
             {
                 Beatmap = database.GetWorkingBeatmap(beatmap, Beatmap);

osu.Game/osu.Game.csproj

@@ -189,6 +189,7 @@
     <Compile Include="Database\RulesetDatabase.cs" />
     <Compile Include="Rulesets\Scoring\Score.cs" />
     <Compile Include="Rulesets\Scoring\ScoreProcessor.cs" />
+    <Compile Include="Screens\Menu\MenuSideFlashes.cs" />
     <Compile Include="Screens\Play\HUD\HealthDisplay.cs" />
     <Compile Include="Screens\Play\HUDOverlay.cs" />
     <Compile Include="Screens\Play\HUD\StandardHealthDisplay.cs" />