diff --git a/osu.Game.Tests/Online/TestSceneOnlinePlayBeatmapAvailabilityTracker.cs b/osu.Game.Tests/Online/TestSceneOnlinePlayBeatmapAvailabilityTracker.cs
index d3475de157..3ffb512b7f 100644
--- a/osu.Game.Tests/Online/TestSceneOnlinePlayBeatmapAvailabilityTracker.cs
+++ b/osu.Game.Tests/Online/TestSceneOnlinePlayBeatmapAvailabilityTracker.cs
@@ -165,10 +165,10 @@ namespace osu.Game.Tests.Online
             {
             }
 
-            public override async Task<BeatmapSetInfo> Import(BeatmapSetInfo item, ArchiveReader archive = null, CancellationToken cancellationToken = default)
+            public override async Task<BeatmapSetInfo> Import(BeatmapSetInfo item, ArchiveReader archive = null, bool lowPriority = false, CancellationToken cancellationToken = default)
             {
                 await AllowImport.Task;
-                return await (CurrentImportTask = base.Import(item, archive, cancellationToken));
+                return await (CurrentImportTask = base.Import(item, archive, lowPriority, cancellationToken));
             }
         }
 
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneLoungeRoomsContainer.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneLoungeRoomsContainer.cs
index 279dcfa584..5682fd5c3c 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneLoungeRoomsContainer.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneLoungeRoomsContainer.cs
@@ -69,6 +69,20 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddAssert("last room joined", () => RoomManager.Rooms.Last().Status.Value is JoinedRoomStatus);
         }
 
+        [Test]
+        public void TestClickDeselection()
+        {
+            AddRooms(1);
+
+            AddAssert("no selection", () => checkRoomSelected(null));
+
+            press(Key.Down);
+            AddAssert("first room selected", () => checkRoomSelected(RoomManager.Rooms.First()));
+
+            AddStep("click away", () => InputManager.Click(MouseButton.Left));
+            AddAssert("no selection", () => checkRoomSelected(null));
+        }
+
         private void press(Key down)
         {
             AddStep($"press {down}", () => InputManager.Key(down));
diff --git a/osu.Game.Tournament/TournamentGameBase.cs b/osu.Game.Tournament/TournamentGameBase.cs
index 4224da4bbe..ffda101ee0 100644
--- a/osu.Game.Tournament/TournamentGameBase.cs
+++ b/osu.Game.Tournament/TournamentGameBase.cs
@@ -152,7 +152,7 @@ namespace osu.Game.Tournament
                 {
                     if (string.IsNullOrEmpty(p.Username) || p.Statistics == null)
                     {
-                        PopulateUser(p);
+                        PopulateUser(p, immediate: true);
                         addedInfo = true;
                     }
                 }
@@ -211,12 +211,14 @@ namespace osu.Game.Tournament
             return addedInfo;
         }
 
-        public void PopulateUser(User user, Action success = null, Action failure = null)
+        public void PopulateUser(User user, Action success = null, Action failure = null, bool immediate = false)
         {
             var req = new GetUserRequest(user.Id, Ruleset.Value);
 
             req.Success += res =>
             {
+                user.Id = res.Id;
+
                 user.Username = res.Username;
                 user.Statistics = res.Statistics;
                 user.Country = res.Country;
@@ -231,7 +233,10 @@ namespace osu.Game.Tournament
                 failure?.Invoke();
             };
 
-            API.Queue(req);
+            if (immediate)
+                API.Perform(req);
+            else
+                API.Queue(req);
         }
 
         protected override void LoadComplete()
diff --git a/osu.Game/Audio/PreviewTrackManager.cs b/osu.Game/Audio/PreviewTrackManager.cs
index 8d02af6574..d88fd1e62b 100644
--- a/osu.Game/Audio/PreviewTrackManager.cs
+++ b/osu.Game/Audio/PreviewTrackManager.cs
@@ -27,6 +27,8 @@ namespace osu.Game.Audio
 
         protected TrackManagerPreviewTrack CurrentTrack;
 
+        private readonly BindableNumber<double> globalTrackVolumeAdjust = new BindableNumber<double>(OsuGameBase.GLOBAL_TRACK_VOLUME_ADJUST);
+
         [BackgroundDependencyLoader]
         private void load()
         {
@@ -35,6 +37,7 @@ namespace osu.Game.Audio
             trackStore = new PreviewTrackStore(new OnlineStore());
 
             audio.AddItem(trackStore);
+            trackStore.AddAdjustment(AdjustableProperty.Volume, globalTrackVolumeAdjust);
             trackStore.AddAdjustment(AdjustableProperty.Volume, audio.VolumeTrack);
         }
 
diff --git a/osu.Game/Beatmaps/BeatmapMetadata.cs b/osu.Game/Beatmaps/BeatmapMetadata.cs
index 39b3c23ddd..367f612dc8 100644
--- a/osu.Game/Beatmaps/BeatmapMetadata.cs
+++ b/osu.Game/Beatmaps/BeatmapMetadata.cs
@@ -51,7 +51,12 @@ namespace osu.Game.Beatmaps
         [JsonProperty(@"tags")]
         public string Tags { get; set; }
 
+        /// <summary>
+        /// The time in milliseconds to begin playing the track for preview purposes.
+        /// If -1, the track should begin playing at 40% of its length.
+        /// </summary>
         public int PreviewTime { get; set; }
+
         public string AudioFile { get; set; }
         public string BackgroundFile { get; set; }
 
diff --git a/osu.Game/Beatmaps/WorkingBeatmap.cs b/osu.Game/Beatmaps/WorkingBeatmap.cs
index 30382c444f..aab8ff6bd6 100644
--- a/osu.Game/Beatmaps/WorkingBeatmap.cs
+++ b/osu.Game/Beatmaps/WorkingBeatmap.cs
@@ -266,6 +266,26 @@ namespace osu.Game.Beatmaps
         [NotNull]
         public Track LoadTrack() => loadedTrack = GetBeatmapTrack() ?? GetVirtualTrack(1000);
 
+        /// <summary>
+        /// Reads the correct track restart point from beatmap metadata and sets looping to enabled.
+        /// </summary>
+        public void PrepareTrackForPreviewLooping()
+        {
+            Track.Looping = true;
+            Track.RestartPoint = Metadata.PreviewTime;
+
+            if (Track.RestartPoint == -1)
+            {
+                if (!Track.IsLoaded)
+                {
+                    // force length to be populated (https://github.com/ppy/osu-framework/issues/4202)
+                    Track.Seek(Track.CurrentTime);
+                }
+
+                Track.RestartPoint = 0.4f * Track.Length;
+            }
+        }
+
         /// <summary>
         /// Transfer a valid audio track into this working beatmap. Used as an optimisation to avoid reload / track swap
         /// across difficulties in the same beatmap set.
diff --git a/osu.Game/Collections/CollectionFilterDropdown.cs b/osu.Game/Collections/CollectionFilterDropdown.cs
index ec0e9d5a89..bb743d4ccc 100644
--- a/osu.Game/Collections/CollectionFilterDropdown.cs
+++ b/osu.Game/Collections/CollectionFilterDropdown.cs
@@ -29,6 +29,14 @@ namespace osu.Game.Collections
         /// </summary>
         protected virtual bool ShowManageCollectionsItem => true;
 
+        private readonly BindableWithCurrent<CollectionFilterMenuItem> current = new BindableWithCurrent<CollectionFilterMenuItem>();
+
+        public new Bindable<CollectionFilterMenuItem> Current
+        {
+            get => current.Current;
+            set => current.Current = value;
+        }
+
         private readonly IBindableList<BeatmapCollection> collections = new BindableList<BeatmapCollection>();
         private readonly IBindableList<BeatmapInfo> beatmaps = new BindableList<BeatmapInfo>();
         private readonly BindableList<CollectionFilterMenuItem> filters = new BindableList<CollectionFilterMenuItem>();
@@ -36,25 +44,28 @@ namespace osu.Game.Collections
         [Resolved(CanBeNull = true)]
         private ManageCollectionsDialog manageCollectionsDialog { get; set; }
 
+        [Resolved(CanBeNull = true)]
+        private CollectionManager collectionManager { get; set; }
+
         public CollectionFilterDropdown()
         {
             ItemSource = filters;
-        }
-
-        [BackgroundDependencyLoader(permitNulls: true)]
-        private void load([CanBeNull] CollectionManager collectionManager)
-        {
-            if (collectionManager != null)
-                collections.BindTo(collectionManager.Collections);
-
-            collections.CollectionChanged += (_, __) => collectionsChanged();
-            collectionsChanged();
+            Current.Value = new AllBeatmapsCollectionFilterMenuItem();
         }
 
         protected override void LoadComplete()
         {
             base.LoadComplete();
 
+            if (collectionManager != null)
+                collections.BindTo(collectionManager.Collections);
+
+            // Dropdown has logic which triggers a change on the bindable with every change to the contained items.
+            // This is not desirable here, as it leads to multiple filter operations running even though nothing has changed.
+            // An extra bindable is enough to subvert this behaviour.
+            base.Current = Current;
+
+            collections.BindCollectionChanged((_, __) => collectionsChanged(), true);
             Current.BindValueChanged(filterChanged, true);
         }
 
diff --git a/osu.Game/Collections/CollectionFilterMenuItem.cs b/osu.Game/Collections/CollectionFilterMenuItem.cs
index 4a489d2945..fe79358223 100644
--- a/osu.Game/Collections/CollectionFilterMenuItem.cs
+++ b/osu.Game/Collections/CollectionFilterMenuItem.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 JetBrains.Annotations;
 using osu.Framework.Bindables;
 
@@ -9,7 +10,7 @@ namespace osu.Game.Collections
     /// <summary>
     /// A <see cref="BeatmapCollection"/> filter.
     /// </summary>
-    public class CollectionFilterMenuItem
+    public class CollectionFilterMenuItem : IEquatable<CollectionFilterMenuItem>
     {
         /// <summary>
         /// The collection to filter beatmaps from.
@@ -33,6 +34,11 @@ namespace osu.Game.Collections
             Collection = collection;
             CollectionName = Collection?.Name.GetBoundCopy() ?? new Bindable<string>("All beatmaps");
         }
+
+        public bool Equals(CollectionFilterMenuItem other)
+            => other != null && CollectionName.Value == other.CollectionName.Value;
+
+        public override int GetHashCode() => CollectionName.Value.GetHashCode();
     }
 
     public class AllBeatmapsCollectionFilterMenuItem : CollectionFilterMenuItem
diff --git a/osu.Game/Collections/CollectionManager.cs b/osu.Game/Collections/CollectionManager.cs
index 569ac749a4..a65d9a415d 100644
--- a/osu.Game/Collections/CollectionManager.cs
+++ b/osu.Game/Collections/CollectionManager.cs
@@ -139,35 +139,43 @@ namespace osu.Game.Collections
             PostNotification?.Invoke(notification);
 
             var collection = readCollections(stream, notification);
-            bool importCompleted = false;
-
-            Schedule(() =>
-            {
-                importCollections(collection);
-                importCompleted = true;
-            });
-
-            while (!IsDisposed && !importCompleted)
-                await Task.Delay(10);
+            await importCollections(collection);
 
             notification.CompletionText = $"Imported {collection.Count} collections";
             notification.State = ProgressNotificationState.Completed;
         }
 
-        private void importCollections(List<BeatmapCollection> newCollections)
+        private Task importCollections(List<BeatmapCollection> newCollections)
         {
-            foreach (var newCol in newCollections)
-            {
-                var existing = Collections.FirstOrDefault(c => c.Name == newCol.Name);
-                if (existing == null)
-                    Collections.Add(existing = new BeatmapCollection { Name = { Value = newCol.Name.Value } });
+            var tcs = new TaskCompletionSource<bool>();
 
-                foreach (var newBeatmap in newCol.Beatmaps)
+            Schedule(() =>
+            {
+                try
                 {
-                    if (!existing.Beatmaps.Contains(newBeatmap))
-                        existing.Beatmaps.Add(newBeatmap);
+                    foreach (var newCol in newCollections)
+                    {
+                        var existing = Collections.FirstOrDefault(c => c.Name == newCol.Name);
+                        if (existing == null)
+                            Collections.Add(existing = new BeatmapCollection { Name = { Value = newCol.Name.Value } });
+
+                        foreach (var newBeatmap in newCol.Beatmaps)
+                        {
+                            if (!existing.Beatmaps.Contains(newBeatmap))
+                                existing.Beatmaps.Add(newBeatmap);
+                        }
+                    }
+
+                    tcs.SetResult(true);
                 }
-            }
+                catch (Exception e)
+                {
+                    Logger.Error(e, "Failed to import collection.");
+                    tcs.SetException(e);
+                }
+            });
+
+            return tcs.Task;
         }
 
         private List<BeatmapCollection> readCollections(Stream stream, ProgressNotification notification = null)
diff --git a/osu.Game/Configuration/ScoreMeterType.cs b/osu.Game/Configuration/ScoreMeterType.cs
index b9499c758e..ddbd2327c2 100644
--- a/osu.Game/Configuration/ScoreMeterType.cs
+++ b/osu.Game/Configuration/ScoreMeterType.cs
@@ -16,12 +16,12 @@ namespace osu.Game.Configuration
         [Description("Hit Error (right)")]
         HitErrorRight,
 
-        [Description("Hit Error (bottom)")]
-        HitErrorBottom,
-
         [Description("Hit Error (left+right)")]
         HitErrorBoth,
 
+        [Description("Hit Error (bottom)")]
+        HitErrorBottom,
+
         [Description("Colour (left)")]
         ColourLeft,
 
diff --git a/osu.Game/Database/ArchiveModelManager.cs b/osu.Game/Database/ArchiveModelManager.cs
index 232acba4a3..03b8db2cb8 100644
--- a/osu.Game/Database/ArchiveModelManager.cs
+++ b/osu.Game/Database/ArchiveModelManager.cs
@@ -38,6 +38,11 @@ namespace osu.Game.Database
     {
         private const int import_queue_request_concurrency = 1;
 
+        /// <summary>
+        /// The size of a batch import operation before considering it a lower priority operation.
+        /// </summary>
+        private const int low_priority_import_batch_size = 1;
+
         /// <summary>
         /// A singleton scheduler shared by all <see cref="ArchiveModelManager{TModel,TFileModel}"/>.
         /// </summary>
@@ -47,6 +52,13 @@ namespace osu.Game.Database
         /// </remarks>
         private static readonly ThreadedTaskScheduler import_scheduler = new ThreadedTaskScheduler(import_queue_request_concurrency, nameof(ArchiveModelManager<TModel, TFileModel>));
 
+        /// <summary>
+        /// A second scheduler for lower priority imports.
+        /// For simplicity, these will just run in parallel with normal priority imports, but a future refactor would see this implemented via a custom scheduler/queue.
+        /// See https://gist.github.com/peppy/f0e118a14751fc832ca30dd48ba3876b for an incomplete version of this.
+        /// </summary>
+        private static readonly ThreadedTaskScheduler import_scheduler_low_priority = new ThreadedTaskScheduler(import_queue_request_concurrency, nameof(ArchiveModelManager<TModel, TFileModel>));
+
         /// <summary>
         /// Set an endpoint for notifications to be posted to.
         /// </summary>
@@ -103,8 +115,11 @@ namespace osu.Game.Database
 
         /// <summary>
         /// Import one or more <typeparamref name="TModel"/> items from filesystem <paramref name="paths"/>.
-        /// This will post notifications tracking progress.
         /// </summary>
+        /// <remarks>
+        /// This will be treated as a low priority import if more than one path is specified; use <see cref="Import(ImportTask[])"/> to always import at standard priority.
+        /// This will post notifications tracking progress.
+        /// </remarks>
         /// <param name="paths">One or more archive locations on disk.</param>
         public Task Import(params string[] paths)
         {
@@ -133,13 +148,15 @@ namespace osu.Game.Database
 
             var imported = new List<TModel>();
 
+            bool isLowPriorityImport = tasks.Length > low_priority_import_batch_size;
+
             await Task.WhenAll(tasks.Select(async task =>
             {
                 notification.CancellationToken.ThrowIfCancellationRequested();
 
                 try
                 {
-                    var model = await Import(task, notification.CancellationToken);
+                    var model = await Import(task, isLowPriorityImport, notification.CancellationToken);
 
                     lock (imported)
                     {
@@ -193,15 +210,16 @@ namespace osu.Game.Database
         /// Note that this bypasses the UI flow and should only be used for special cases or testing.
         /// </summary>
         /// <param name="task">The <see cref="ImportTask"/> containing data about the <typeparamref name="TModel"/> to import.</param>
+        /// <param name="lowPriority">Whether this is a low priority import.</param>
         /// <param name="cancellationToken">An optional cancellation token.</param>
         /// <returns>The imported model, if successful.</returns>
-        internal async Task<TModel> Import(ImportTask task, CancellationToken cancellationToken = default)
+        internal async Task<TModel> Import(ImportTask task, bool lowPriority = false, CancellationToken cancellationToken = default)
         {
             cancellationToken.ThrowIfCancellationRequested();
 
             TModel import;
             using (ArchiveReader reader = task.GetReader())
-                import = await Import(reader, cancellationToken);
+                import = await Import(reader, lowPriority, cancellationToken);
 
             // We may or may not want to delete the file depending on where it is stored.
             //  e.g. reconstructing/repairing database with items from default storage.
@@ -226,11 +244,12 @@ namespace osu.Game.Database
         public Action<IEnumerable<TModel>> PresentImport;
 
         /// <summary>
-        /// Import an item from an <see cref="ArchiveReader"/>.
+        /// Silently import an item from an <see cref="ArchiveReader"/>.
         /// </summary>
         /// <param name="archive">The archive to be imported.</param>
+        /// <param name="lowPriority">Whether this is a low priority import.</param>
         /// <param name="cancellationToken">An optional cancellation token.</param>
-        public Task<TModel> Import(ArchiveReader archive, CancellationToken cancellationToken = default)
+        public Task<TModel> Import(ArchiveReader archive, bool lowPriority = false, CancellationToken cancellationToken = default)
         {
             cancellationToken.ThrowIfCancellationRequested();
 
@@ -253,7 +272,7 @@ namespace osu.Game.Database
                 return null;
             }
 
-            return Import(model, archive, cancellationToken);
+            return Import(model, archive, lowPriority, cancellationToken);
         }
 
         /// <summary>
@@ -303,12 +322,13 @@ namespace osu.Game.Database
         }
 
         /// <summary>
-        /// Import an item from a <typeparamref name="TModel"/>.
+        /// Silently import an item from a <typeparamref name="TModel"/>.
         /// </summary>
         /// <param name="item">The model to be imported.</param>
         /// <param name="archive">An optional archive to use for model population.</param>
+        /// <param name="lowPriority">Whether this is a low priority import.</param>
         /// <param name="cancellationToken">An optional cancellation token.</param>
-        public virtual async Task<TModel> Import(TModel item, ArchiveReader archive = null, CancellationToken cancellationToken = default) => await Task.Factory.StartNew(async () =>
+        public virtual async Task<TModel> Import(TModel item, ArchiveReader archive = null, bool lowPriority = false, CancellationToken cancellationToken = default) => await Task.Factory.StartNew(async () =>
         {
             cancellationToken.ThrowIfCancellationRequested();
 
@@ -383,7 +403,7 @@ namespace osu.Game.Database
 
             flushEvents(true);
             return item;
-        }, cancellationToken, TaskCreationOptions.HideScheduler, import_scheduler).Unwrap();
+        }, cancellationToken, TaskCreationOptions.HideScheduler, lowPriority ? import_scheduler_low_priority : import_scheduler).Unwrap();
 
         /// <summary>
         /// Exports an item to a legacy (.zip based) package.
diff --git a/osu.Game/Online/API/Requests/Responses/APIUserScoreAggregate.cs b/osu.Game/Online/API/Requests/Responses/APIUserScoreAggregate.cs
index bcc8721400..172fa3a583 100644
--- a/osu.Game/Online/API/Requests/Responses/APIUserScoreAggregate.cs
+++ b/osu.Game/Online/API/Requests/Responses/APIUserScoreAggregate.cs
@@ -22,7 +22,7 @@ namespace osu.Game.Online.API.Requests.Responses
         public double? PP { get; set; }
 
         [JsonProperty(@"room_id")]
-        public int RoomID { get; set; }
+        public long RoomID { get; set; }
 
         [JsonProperty("total_score")]
         public long TotalScore { get; set; }
diff --git a/osu.Game/Online/Multiplayer/StatefulMultiplayerClient.cs b/osu.Game/Online/Multiplayer/StatefulMultiplayerClient.cs
index 18464a5f61..639dce9230 100644
--- a/osu.Game/Online/Multiplayer/StatefulMultiplayerClient.cs
+++ b/osu.Game/Online/Multiplayer/StatefulMultiplayerClient.cs
@@ -95,7 +95,7 @@ namespace osu.Game.Online.Multiplayer
         private Room? apiRoom;
 
         // Todo: This is temporary, until the multiplayer server returns the item id on match start or otherwise.
-        private int playlistItemId;
+        private long playlistItemId;
 
         [BackgroundDependencyLoader]
         private void load()
diff --git a/osu.Game/Online/OnlineViewContainer.cs b/osu.Game/Online/OnlineViewContainer.cs
index c9fb70f0cc..8868f90524 100644
--- a/osu.Game/Online/OnlineViewContainer.cs
+++ b/osu.Game/Online/OnlineViewContainer.cs
@@ -15,7 +15,7 @@ namespace osu.Game.Online
     /// A <see cref="Container"/> for displaying online content which require a local user to be logged in.
     /// Shows its children only when the local user is logged in and supports displaying a placeholder if not.
     /// </summary>
-    public abstract class OnlineViewContainer : Container
+    public class OnlineViewContainer : Container
     {
         protected LoadingSpinner LoadingSpinner { get; private set; }
 
@@ -30,7 +30,7 @@ namespace osu.Game.Online
         [Resolved]
         protected IAPIProvider API { get; private set; }
 
-        protected OnlineViewContainer(string placeholderMessage)
+        public OnlineViewContainer(string placeholderMessage)
         {
             this.placeholderMessage = placeholderMessage;
         }
diff --git a/osu.Game/Online/Rooms/CreateRoomScoreRequest.cs b/osu.Game/Online/Rooms/CreateRoomScoreRequest.cs
index afd0dadc7e..d4303e77df 100644
--- a/osu.Game/Online/Rooms/CreateRoomScoreRequest.cs
+++ b/osu.Game/Online/Rooms/CreateRoomScoreRequest.cs
@@ -9,11 +9,11 @@ namespace osu.Game.Online.Rooms
 {
     public class CreateRoomScoreRequest : APIRequest<APIScoreToken>
     {
-        private readonly int roomId;
-        private readonly int playlistItemId;
+        private readonly long roomId;
+        private readonly long playlistItemId;
         private readonly string versionHash;
 
-        public CreateRoomScoreRequest(int roomId, int playlistItemId, string versionHash)
+        public CreateRoomScoreRequest(long roomId, long playlistItemId, string versionHash)
         {
             this.roomId = roomId;
             this.playlistItemId = playlistItemId;
diff --git a/osu.Game/Online/Rooms/GetRoomLeaderboardRequest.cs b/osu.Game/Online/Rooms/GetRoomLeaderboardRequest.cs
index 15f1221a00..67e2a2b27f 100644
--- a/osu.Game/Online/Rooms/GetRoomLeaderboardRequest.cs
+++ b/osu.Game/Online/Rooms/GetRoomLeaderboardRequest.cs
@@ -7,9 +7,9 @@ namespace osu.Game.Online.Rooms
 {
     public class GetRoomLeaderboardRequest : APIRequest<APILeaderboard>
     {
-        private readonly int roomId;
+        private readonly long roomId;
 
-        public GetRoomLeaderboardRequest(int roomId)
+        public GetRoomLeaderboardRequest(long roomId)
         {
             this.roomId = roomId;
         }
diff --git a/osu.Game/Online/Rooms/GetRoomRequest.cs b/osu.Game/Online/Rooms/GetRoomRequest.cs
index ce117075c7..853873901e 100644
--- a/osu.Game/Online/Rooms/GetRoomRequest.cs
+++ b/osu.Game/Online/Rooms/GetRoomRequest.cs
@@ -7,9 +7,9 @@ namespace osu.Game.Online.Rooms
 {
     public class GetRoomRequest : APIRequest<Room>
     {
-        public readonly int RoomId;
+        public readonly long RoomId;
 
-        public GetRoomRequest(int roomId)
+        public GetRoomRequest(long roomId)
         {
             RoomId = roomId;
         }
diff --git a/osu.Game/Online/Rooms/IndexPlaylistScoresRequest.cs b/osu.Game/Online/Rooms/IndexPlaylistScoresRequest.cs
index 43f80a2dc4..abce2093e3 100644
--- a/osu.Game/Online/Rooms/IndexPlaylistScoresRequest.cs
+++ b/osu.Game/Online/Rooms/IndexPlaylistScoresRequest.cs
@@ -15,8 +15,8 @@ namespace osu.Game.Online.Rooms
     /// </summary>
     public class IndexPlaylistScoresRequest : APIRequest<IndexedMultiplayerScores>
     {
-        public readonly int RoomId;
-        public readonly int PlaylistItemId;
+        public readonly long RoomId;
+        public readonly long PlaylistItemId;
 
         [CanBeNull]
         public readonly Cursor Cursor;
@@ -24,13 +24,13 @@ namespace osu.Game.Online.Rooms
         [CanBeNull]
         public readonly IndexScoresParams IndexParams;
 
-        public IndexPlaylistScoresRequest(int roomId, int playlistItemId)
+        public IndexPlaylistScoresRequest(long roomId, long playlistItemId)
         {
             RoomId = roomId;
             PlaylistItemId = playlistItemId;
         }
 
-        public IndexPlaylistScoresRequest(int roomId, int playlistItemId, [NotNull] Cursor cursor, [NotNull] IndexScoresParams indexParams)
+        public IndexPlaylistScoresRequest(long roomId, long playlistItemId, [NotNull] Cursor cursor, [NotNull] IndexScoresParams indexParams)
             : this(roomId, playlistItemId)
         {
             Cursor = cursor;
diff --git a/osu.Game/Online/Rooms/ItemAttemptsCount.cs b/osu.Game/Online/Rooms/ItemAttemptsCount.cs
new file mode 100644
index 0000000000..298603d778
--- /dev/null
+++ b/osu.Game/Online/Rooms/ItemAttemptsCount.cs
@@ -0,0 +1,19 @@
+// 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 Newtonsoft.Json;
+
+namespace osu.Game.Online.Rooms
+{
+    /// <summary>
+    /// Represents attempts on a specific playlist item.
+    /// </summary>
+    public class ItemAttemptsCount
+    {
+        [JsonProperty("id")]
+        public int PlaylistItemID { get; set; }
+
+        [JsonProperty("attempts")]
+        public int Attempts { get; set; }
+    }
+}
diff --git a/osu.Game/Online/Rooms/MultiplayerScore.cs b/osu.Game/Online/Rooms/MultiplayerScore.cs
index 677a3d3026..30c1d2f826 100644
--- a/osu.Game/Online/Rooms/MultiplayerScore.cs
+++ b/osu.Game/Online/Rooms/MultiplayerScore.cs
@@ -18,7 +18,7 @@ namespace osu.Game.Online.Rooms
     public class MultiplayerScore
     {
         [JsonProperty("id")]
-        public int ID { get; set; }
+        public long ID { get; set; }
 
         [JsonProperty("user")]
         public User User { get; set; }
diff --git a/osu.Game/Online/Rooms/PlaylistAggregateScore.cs b/osu.Game/Online/Rooms/PlaylistAggregateScore.cs
new file mode 100644
index 0000000000..61e0951cd5
--- /dev/null
+++ b/osu.Game/Online/Rooms/PlaylistAggregateScore.cs
@@ -0,0 +1,16 @@
+// 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 Newtonsoft.Json;
+
+namespace osu.Game.Online.Rooms
+{
+    /// <summary>
+    /// Represents aggregated score for the local user for a playlist.
+    /// </summary>
+    public class PlaylistAggregateScore
+    {
+        [JsonProperty("playlist_item_attempts")]
+        public ItemAttemptsCount[] PlaylistItemAttempts { get; set; }
+    }
+}
diff --git a/osu.Game/Online/Rooms/PlaylistItem.cs b/osu.Game/Online/Rooms/PlaylistItem.cs
index ada2140ca6..61982101c1 100644
--- a/osu.Game/Online/Rooms/PlaylistItem.cs
+++ b/osu.Game/Online/Rooms/PlaylistItem.cs
@@ -15,7 +15,7 @@ namespace osu.Game.Online.Rooms
     public class PlaylistItem : IEquatable<PlaylistItem>
     {
         [JsonProperty("id")]
-        public int ID { get; set; }
+        public long ID { get; set; }
 
         [JsonProperty("beatmap_id")]
         public int BeatmapID { get; set; }
diff --git a/osu.Game/Online/Rooms/Room.cs b/osu.Game/Online/Rooms/Room.cs
index 763ba25d52..1774eb4aca 100644
--- a/osu.Game/Online/Rooms/Room.cs
+++ b/osu.Game/Online/Rooms/Room.cs
@@ -17,7 +17,7 @@ namespace osu.Game.Online.Rooms
     {
         [Cached]
         [JsonProperty("id")]
-        public readonly Bindable<int?> RoomID = new Bindable<int?>();
+        public readonly Bindable<long?> RoomID = new Bindable<long?>();
 
         [Cached]
         [JsonProperty("name")]
@@ -72,6 +72,10 @@ namespace osu.Game.Online.Rooms
         [JsonIgnore]
         public readonly Bindable<int?> MaxParticipants = new Bindable<int?>();
 
+        [Cached]
+        [JsonProperty("current_user_score")]
+        public readonly Bindable<PlaylistAggregateScore> UserScore = new Bindable<PlaylistAggregateScore>();
+
         [Cached]
         [JsonProperty("recent_participants")]
         public readonly BindableList<User> RecentParticipants = new BindableList<User>();
@@ -144,6 +148,7 @@ namespace osu.Game.Online.Rooms
             MaxParticipants.Value = other.MaxParticipants.Value;
             ParticipantCount.Value = other.ParticipantCount.Value;
             EndDate.Value = other.EndDate.Value;
+            UserScore.Value = other.UserScore.Value;
 
             if (EndDate.Value != null && DateTimeOffset.Now >= EndDate.Value)
                 Status.Value = new RoomStatusEnded();
diff --git a/osu.Game/Online/Rooms/ShowPlaylistUserScoreRequest.cs b/osu.Game/Online/Rooms/ShowPlaylistUserScoreRequest.cs
index 3f728a5417..ba3e3c6349 100644
--- a/osu.Game/Online/Rooms/ShowPlaylistUserScoreRequest.cs
+++ b/osu.Game/Online/Rooms/ShowPlaylistUserScoreRequest.cs
@@ -7,11 +7,11 @@ namespace osu.Game.Online.Rooms
 {
     public class ShowPlaylistUserScoreRequest : APIRequest<MultiplayerScore>
     {
-        private readonly int roomId;
-        private readonly int playlistItemId;
+        private readonly long roomId;
+        private readonly long playlistItemId;
         private readonly long userId;
 
-        public ShowPlaylistUserScoreRequest(int roomId, int playlistItemId, long userId)
+        public ShowPlaylistUserScoreRequest(long roomId, long playlistItemId, long userId)
         {
             this.roomId = roomId;
             this.playlistItemId = playlistItemId;
diff --git a/osu.Game/Online/Rooms/SubmitRoomScoreRequest.cs b/osu.Game/Online/Rooms/SubmitRoomScoreRequest.cs
index 5a78b9fabd..9e432fa99e 100644
--- a/osu.Game/Online/Rooms/SubmitRoomScoreRequest.cs
+++ b/osu.Game/Online/Rooms/SubmitRoomScoreRequest.cs
@@ -11,12 +11,12 @@ namespace osu.Game.Online.Rooms
 {
     public class SubmitRoomScoreRequest : APIRequest<MultiplayerScore>
     {
-        private readonly int scoreId;
-        private readonly int roomId;
-        private readonly int playlistItemId;
+        private readonly long scoreId;
+        private readonly long roomId;
+        private readonly long playlistItemId;
         private readonly ScoreInfo scoreInfo;
 
-        public SubmitRoomScoreRequest(int scoreId, int roomId, int playlistItemId, ScoreInfo scoreInfo)
+        public SubmitRoomScoreRequest(long scoreId, long roomId, long playlistItemId, ScoreInfo scoreInfo)
         {
             this.scoreId = scoreId;
             this.roomId = roomId;
diff --git a/osu.Game/OsuGameBase.cs b/osu.Game/OsuGameBase.cs
index 00b436931a..3d24f245f9 100644
--- a/osu.Game/OsuGameBase.cs
+++ b/osu.Game/OsuGameBase.cs
@@ -156,7 +156,12 @@ namespace osu.Game
 
         protected override UserInputManager CreateUserInputManager() => new OsuUserInputManager();
 
-        private readonly BindableNumber<double> globalTrackVolumeAdjust = new BindableNumber<double>(0.5f);
+        /// <summary>
+        /// The maximum volume at which audio tracks should playback. This can be set lower than 1 to create some head-room for sound effects.
+        /// </summary>
+        internal const double GLOBAL_TRACK_VOLUME_ADJUST = 0.5;
+
+        private readonly BindableNumber<double> globalTrackVolumeAdjust = new BindableNumber<double>(GLOBAL_TRACK_VOLUME_ADJUST);
 
         [BackgroundDependencyLoader]
         private void load()
diff --git a/osu.Game/Overlays/ChangelogOverlay.cs b/osu.Game/Overlays/ChangelogOverlay.cs
index 593f59555a..537dd00727 100644
--- a/osu.Game/Overlays/ChangelogOverlay.cs
+++ b/osu.Game/Overlays/ChangelogOverlay.cs
@@ -30,7 +30,7 @@ namespace osu.Game.Overlays
         protected List<APIUpdateStream> Streams;
 
         public ChangelogOverlay()
-            : base(OverlayColourScheme.Purple)
+            : base(OverlayColourScheme.Purple, false)
         {
         }
 
diff --git a/osu.Game/Overlays/ChatOverlay.cs b/osu.Game/Overlays/ChatOverlay.cs
index 8bc7e21047..28f2287514 100644
--- a/osu.Game/Overlays/ChatOverlay.cs
+++ b/osu.Game/Overlays/ChatOverlay.cs
@@ -24,6 +24,7 @@ using osu.Game.Overlays.Chat.Tabs;
 using osuTK.Input;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
+using osu.Game.Online;
 
 namespace osu.Game.Overlays
 {
@@ -118,40 +119,47 @@ namespace osu.Game.Overlays
                                 {
                                     RelativeSizeAxes = Axes.Both,
                                 },
-                                currentChannelContainer = new Container<DrawableChannel>
+                                new OnlineViewContainer("Sign in to chat")
                                 {
                                     RelativeSizeAxes = Axes.Both,
-                                    Padding = new MarginPadding
-                                    {
-                                        Bottom = textbox_height
-                                    },
-                                },
-                                new Container
-                                {
-                                    Anchor = Anchor.BottomLeft,
-                                    Origin = Anchor.BottomLeft,
-                                    RelativeSizeAxes = Axes.X,
-                                    Height = textbox_height,
-                                    Padding = new MarginPadding
-                                    {
-                                        Top = padding * 2,
-                                        Bottom = padding * 2,
-                                        Left = ChatLine.LEFT_PADDING + padding * 2,
-                                        Right = padding * 2,
-                                    },
                                     Children = new Drawable[]
                                     {
-                                        textbox = new FocusedTextBox
+                                        currentChannelContainer = new Container<DrawableChannel>
                                         {
                                             RelativeSizeAxes = Axes.Both,
-                                            Height = 1,
-                                            PlaceholderText = "type your message",
-                                            ReleaseFocusOnCommit = false,
-                                            HoldFocus = true,
-                                        }
-                                    }
-                                },
-                                loading = new LoadingSpinner(),
+                                            Padding = new MarginPadding
+                                            {
+                                                Bottom = textbox_height
+                                            },
+                                        },
+                                        new Container
+                                        {
+                                            Anchor = Anchor.BottomLeft,
+                                            Origin = Anchor.BottomLeft,
+                                            RelativeSizeAxes = Axes.X,
+                                            Height = textbox_height,
+                                            Padding = new MarginPadding
+                                            {
+                                                Top = padding * 2,
+                                                Bottom = padding * 2,
+                                                Left = ChatLine.LEFT_PADDING + padding * 2,
+                                                Right = padding * 2,
+                                            },
+                                            Children = new Drawable[]
+                                            {
+                                                textbox = new FocusedTextBox
+                                                {
+                                                    RelativeSizeAxes = Axes.Both,
+                                                    Height = 1,
+                                                    PlaceholderText = "type your message",
+                                                    ReleaseFocusOnCommit = false,
+                                                    HoldFocus = true,
+                                                }
+                                            }
+                                        },
+                                        loading = new LoadingSpinner(),
+                                    },
+                                }
                             }
                         },
                         tabsArea = new TabsArea
diff --git a/osu.Game/Overlays/Comments/DrawableComment.cs b/osu.Game/Overlays/Comments/DrawableComment.cs
index 31aa41e967..7c47ac655f 100644
--- a/osu.Game/Overlays/Comments/DrawableComment.cs
+++ b/osu.Game/Overlays/Comments/DrawableComment.cs
@@ -9,7 +9,6 @@ using osuTK;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Users.Drawables;
 using osu.Game.Graphics.Containers;
-using osu.Game.Utils;
 using osu.Framework.Graphics.Cursor;
 using osu.Framework.Bindables;
 using System.Linq;
@@ -245,11 +244,32 @@ namespace osu.Game.Overlays.Comments
 
             if (Comment.EditedAt.HasValue)
             {
-                info.Add(new OsuSpriteText
+                var font = OsuFont.GetFont(size: 12, weight: FontWeight.Regular);
+                var colour = colourProvider.Foreground1;
+
+                info.Add(new FillFlowContainer
                 {
-                    Font = OsuFont.GetFont(size: 12, weight: FontWeight.Regular),
-                    Text = $@"edited {HumanizerUtils.Humanize(Comment.EditedAt.Value)} by {Comment.EditedUser.Username}",
-                    Colour = colourProvider.Foreground1
+                    AutoSizeAxes = Axes.Both,
+                    Children = new Drawable[]
+                    {
+                        new OsuSpriteText
+                        {
+                            Font = font,
+                            Text = "edited ",
+                            Colour = colour
+                        },
+                        new DrawableDate(Comment.EditedAt.Value)
+                        {
+                            Font = font,
+                            Colour = colour
+                        },
+                        new OsuSpriteText
+                        {
+                            Font = font,
+                            Text = $@" by {Comment.EditedUser.Username}",
+                            Colour = colour
+                        },
+                    }
                 });
             }
 
diff --git a/osu.Game/Overlays/NewsOverlay.cs b/osu.Game/Overlays/NewsOverlay.cs
index 08e8331dd3..5beb285216 100644
--- a/osu.Game/Overlays/NewsOverlay.cs
+++ b/osu.Game/Overlays/NewsOverlay.cs
@@ -14,7 +14,7 @@ namespace osu.Game.Overlays
         private readonly Bindable<string> article = new Bindable<string>(null);
 
         public NewsOverlay()
-            : base(OverlayColourScheme.Purple)
+            : base(OverlayColourScheme.Purple, false)
         {
         }
 
diff --git a/osu.Game/Overlays/OnlineOverlay.cs b/osu.Game/Overlays/OnlineOverlay.cs
index 7c9f751d3b..de33e4a1bc 100644
--- a/osu.Game/Overlays/OnlineOverlay.cs
+++ b/osu.Game/Overlays/OnlineOverlay.cs
@@ -4,6 +4,7 @@
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Graphics.UserInterface;
+using osu.Game.Online;
 
 namespace osu.Game.Overlays
 {
@@ -16,10 +17,16 @@ namespace osu.Game.Overlays
         protected readonly LoadingLayer Loading;
         private readonly Container content;
 
-        protected OnlineOverlay(OverlayColourScheme colourScheme)
+        protected OnlineOverlay(OverlayColourScheme colourScheme, bool requiresSignIn = true)
             : base(colourScheme)
         {
-            base.Content.AddRange(new Drawable[]
+            var mainContent = requiresSignIn
+                ? new OnlineViewContainer($"Sign in to view the {Header.Title.Title}")
+                : new Container();
+
+            mainContent.RelativeSizeAxes = Axes.Both;
+
+            mainContent.AddRange(new Drawable[]
             {
                 ScrollFlow = new OverlayScrollContainer
                 {
@@ -43,6 +50,8 @@ namespace osu.Game.Overlays
                 },
                 Loading = new LoadingLayer(true)
             });
+
+            base.Content.Add(mainContent);
         }
     }
 }
diff --git a/osu.Game/Overlays/TabbableOnlineOverlay.cs b/osu.Game/Overlays/TabbableOnlineOverlay.cs
index 8172e99c1b..9ceab12d3d 100644
--- a/osu.Game/Overlays/TabbableOnlineOverlay.cs
+++ b/osu.Game/Overlays/TabbableOnlineOverlay.cs
@@ -61,8 +61,7 @@ namespace osu.Game.Overlays
 
             LoadComponentAsync(display, loaded =>
             {
-                if (API.IsLoggedIn)
-                    Loading.Hide();
+                Loading.Hide();
 
                 Child = loaded;
             }, (cancellationToken = new CancellationTokenSource()).Token);
diff --git a/osu.Game/Screens/Menu/IntroScreen.cs b/osu.Game/Screens/Menu/IntroScreen.cs
index b8b962be6c..71f3b60026 100644
--- a/osu.Game/Screens/Menu/IntroScreen.cs
+++ b/osu.Game/Screens/Menu/IntroScreen.cs
@@ -111,12 +111,10 @@ namespace osu.Game.Screens.Menu
             {
                 setInfo = beatmaps.QueryBeatmapSet(b => b.Hash == BeatmapHash);
 
-                if (setInfo != null)
-                {
-                    initialBeatmap = beatmaps.GetWorkingBeatmap(setInfo.Beatmaps[0]);
-                }
+                if (setInfo == null)
+                    return false;
 
-                return UsingThemedIntro;
+                return (initialBeatmap = beatmaps.GetWorkingBeatmap(setInfo.Beatmaps[0])) != null;
             }
         }
 
@@ -170,7 +168,7 @@ namespace osu.Game.Screens.Menu
         {
             // Only start the current track if it is the menu music. A beatmap's track is started when entering the Main Menu.
             if (UsingThemedIntro)
-                Track.Restart();
+                Track.Start();
         }
 
         protected override void LogoArriving(OsuLogo logo, bool resuming)
diff --git a/osu.Game/Screens/Menu/MainMenu.cs b/osu.Game/Screens/Menu/MainMenu.cs
index 97fd58318b..424e6d2cd5 100644
--- a/osu.Game/Screens/Menu/MainMenu.cs
+++ b/osu.Game/Screens/Menu/MainMenu.cs
@@ -179,14 +179,15 @@ namespace osu.Game.Screens.Menu
             base.OnEntering(last);
             buttons.FadeInFromZero(500);
 
-            var metadata = Beatmap.Value.Metadata;
-
             if (last is IntroScreen && musicController.TrackLoaded)
             {
-                if (!musicController.CurrentTrack.IsRunning)
+                var track = musicController.CurrentTrack;
+
+                // presume the track is the current beatmap's track. not sure how correct this assumption is but it has worked until now.
+                if (!track.IsRunning)
                 {
-                    musicController.CurrentTrack.Seek(metadata.PreviewTime != -1 ? metadata.PreviewTime : 0.4f * musicController.CurrentTrack.Length);
-                    musicController.CurrentTrack.Start();
+                    Beatmap.Value.PrepareTrackForPreviewLooping();
+                    track.Restart();
                 }
             }
 
diff --git a/osu.Game/Screens/OnlinePlay/Components/RoomLocalUserInfo.cs b/osu.Game/Screens/OnlinePlay/Components/RoomLocalUserInfo.cs
index f52e59b0c8..1fcf7f2277 100644
--- a/osu.Game/Screens/OnlinePlay/Components/RoomLocalUserInfo.cs
+++ b/osu.Game/Screens/OnlinePlay/Components/RoomLocalUserInfo.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 osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -39,12 +40,26 @@ namespace osu.Game.Screens.OnlinePlay.Components
         {
             base.LoadComplete();
 
-            MaxAttempts.BindValueChanged(attempts =>
+            MaxAttempts.BindValueChanged(_ => updateAttempts());
+            UserScore.BindValueChanged(_ => updateAttempts(), true);
+        }
+
+        private void updateAttempts()
+        {
+            if (MaxAttempts.Value != null)
             {
-                attemptDisplay.Text = attempts.NewValue == null
-                    ? string.Empty
-                    : $"Maximum attempts: {attempts.NewValue:N0}";
-            }, true);
+                attemptDisplay.Text = $"Maximum attempts: {MaxAttempts.Value:N0}";
+
+                if (UserScore.Value != null)
+                {
+                    int remaining = MaxAttempts.Value.Value - UserScore.Value.PlaylistItemAttempts.Sum(a => a.Attempts);
+                    attemptDisplay.Text += $" ({remaining} remaining)";
+                }
+            }
+            else
+            {
+                attemptDisplay.Text = string.Empty;
+            }
         }
     }
 }
diff --git a/osu.Game/Screens/OnlinePlay/Components/RoomManager.cs b/osu.Game/Screens/OnlinePlay/Components/RoomManager.cs
index 2ed259e2b8..227a772b2d 100644
--- a/osu.Game/Screens/OnlinePlay/Components/RoomManager.cs
+++ b/osu.Game/Screens/OnlinePlay/Components/RoomManager.cs
@@ -116,7 +116,7 @@ namespace osu.Game.Screens.OnlinePlay.Components
             joinedRoom.Value = null;
         }
 
-        private readonly HashSet<int> ignoredRooms = new HashSet<int>();
+        private readonly HashSet<long> ignoredRooms = new HashSet<long>();
 
         private void onRoomsReceived(List<Room> received)
         {
diff --git a/osu.Game/Screens/OnlinePlay/Lounge/Components/RoomsContainer.cs b/osu.Game/Screens/OnlinePlay/Lounge/Components/RoomsContainer.cs
index f70c33babe..8e59dc8579 100644
--- a/osu.Game/Screens/OnlinePlay/Lounge/Components/RoomsContainer.cs
+++ b/osu.Game/Screens/OnlinePlay/Lounge/Components/RoomsContainer.cs
@@ -11,6 +11,7 @@ using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Input.Bindings;
+using osu.Framework.Input.Events;
 using osu.Framework.Threading;
 using osu.Game.Extensions;
 using osu.Game.Graphics.Cursor;
@@ -42,6 +43,9 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
         [Resolved(CanBeNull = true)]
         private LoungeSubScreen loungeSubScreen { get; set; }
 
+        // handle deselection
+        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => true;
+
         public RoomsContainer()
         {
             RelativeSizeAxes = Axes.X;
@@ -69,8 +73,16 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
             rooms.BindTo(roomManager.Rooms);
 
             filter?.BindValueChanged(criteria => Filter(criteria.NewValue));
+
+            selectedRoom.BindValueChanged(selection =>
+            {
+                updateSelection();
+            }, true);
         }
 
+        private void updateSelection() =>
+            roomFlow.Children.ForEach(r => r.State = r.Room == selectedRoom.Value ? SelectionState.Selected : SelectionState.NotSelected);
+
         public void Filter(FilterCriteria criteria)
         {
             roomFlow.Children.ForEach(r =>
@@ -125,6 +137,8 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
             }
 
             Filter(filter?.Value);
+
+            updateSelection();
         }
 
         private void removeRooms(IEnumerable<Room> rooms)
@@ -146,11 +160,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                 roomFlow.SetLayoutPosition(room, room.Room.Position.Value);
         }
 
-        private void selectRoom(Room room)
-        {
-            roomFlow.Children.ForEach(r => r.State = r.Room == room ? SelectionState.Selected : SelectionState.NotSelected);
-            selectedRoom.Value = room;
-        }
+        private void selectRoom(Room room) => selectedRoom.Value = room;
 
         private void joinSelected()
         {
@@ -159,6 +169,12 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
             JoinRequested?.Invoke(selectedRoom.Value);
         }
 
+        protected override bool OnClick(ClickEvent e)
+        {
+            selectRoom(null);
+            return base.OnClick(e);
+        }
+
         #region Key selection logic (shared with BeatmapCarousel)
 
         public bool OnPressed(GlobalAction action)
diff --git a/osu.Game/Screens/OnlinePlay/Match/Components/MatchChatDisplay.cs b/osu.Game/Screens/OnlinePlay/Match/Components/MatchChatDisplay.cs
index 6da2866236..a96d64cb5d 100644
--- a/osu.Game/Screens/OnlinePlay/Match/Components/MatchChatDisplay.cs
+++ b/osu.Game/Screens/OnlinePlay/Match/Components/MatchChatDisplay.cs
@@ -11,7 +11,7 @@ namespace osu.Game.Screens.OnlinePlay.Match.Components
     public class MatchChatDisplay : StandAloneChatDisplay
     {
         [Resolved(typeof(Room), nameof(Room.RoomID))]
-        private Bindable<int?> roomId { get; set; }
+        private Bindable<long?> roomId { get; set; }
 
         [Resolved(typeof(Room), nameof(Room.ChannelId))]
         private Bindable<int> channelId { get; set; }
diff --git a/osu.Game/Screens/OnlinePlay/Match/Components/MatchLeaderboard.cs b/osu.Game/Screens/OnlinePlay/Match/Components/MatchLeaderboard.cs
index 50869f42ff..134e083c42 100644
--- a/osu.Game/Screens/OnlinePlay/Match/Components/MatchLeaderboard.cs
+++ b/osu.Game/Screens/OnlinePlay/Match/Components/MatchLeaderboard.cs
@@ -15,7 +15,7 @@ namespace osu.Game.Screens.OnlinePlay.Match.Components
     public class MatchLeaderboard : Leaderboard<MatchLeaderboardScope, APIUserScoreAggregate>
     {
         [Resolved(typeof(Room), nameof(Room.RoomID))]
-        private Bindable<int?> roomId { get; set; }
+        private Bindable<long?> roomId { get; set; }
 
         [BackgroundDependencyLoader]
         private void load()
diff --git a/osu.Game/Screens/OnlinePlay/Match/RoomSubScreen.cs b/osu.Game/Screens/OnlinePlay/Match/RoomSubScreen.cs
index 24d42283f7..15e12eac40 100644
--- a/osu.Game/Screens/OnlinePlay/Match/RoomSubScreen.cs
+++ b/osu.Game/Screens/OnlinePlay/Match/RoomSubScreen.cs
@@ -231,9 +231,7 @@ namespace osu.Game.Screens.OnlinePlay.Match
 
             if (track != null)
             {
-                track.RestartPoint = Beatmap.Value.Metadata.PreviewTime;
-                track.Looping = true;
-
+                Beatmap.Value.PrepareTrackForPreviewLooping();
                 music?.EnsurePlayingSomething();
             }
         }
@@ -243,10 +241,7 @@ namespace osu.Game.Screens.OnlinePlay.Match
             var track = Beatmap?.Value?.Track;
 
             if (track != null)
-            {
                 track.Looping = false;
-                track.RestartPoint = 0;
-            }
         }
 
         private class UserModSelectOverlay : LocalPlayerModSelectOverlay
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/Match/MultiplayerMatchSettingsOverlay.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/Match/MultiplayerMatchSettingsOverlay.cs
index f0064ae0b4..3199232f6f 100644
--- a/osu.Game/Screens/OnlinePlay/Multiplayer/Match/MultiplayerMatchSettingsOverlay.cs
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/Match/MultiplayerMatchSettingsOverlay.cs
@@ -357,7 +357,7 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Match
         public class CreateOrUpdateButton : TriangleButton
         {
             [Resolved(typeof(Room), nameof(Room.RoomID))]
-            private Bindable<int?> roomId { get; set; }
+            private Bindable<long?> roomId { get; set; }
 
             protected override void LoadComplete()
             {
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerMatchSubScreen.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerMatchSubScreen.cs
index 49ac9f64ff..ca48139287 100644
--- a/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerMatchSubScreen.cs
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerMatchSubScreen.cs
@@ -272,7 +272,7 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
                 return;
 
             // update local mods based on room's reported status for the local user (omitting the base call implementation).
-            // this makes the server authoritative, and avoids the local user potentially settings mods that the server is not aware of (ie. if the match was started during the selection being changed).
+            // this makes the server authoritative, and avoids the local user potentially setting mods that the server is not aware of (ie. if the match was started during the selection being changed).
             var ruleset = Ruleset.Value.CreateInstance();
             Mods.Value = client.LocalUser.Mods.Select(m => m.ToMod(ruleset)).Concat(SelectedItem.Value.RequiredMods).ToList();
         }
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerResultsScreen.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerResultsScreen.cs
index e3b47b3254..140b3c45d8 100644
--- a/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerResultsScreen.cs
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerResultsScreen.cs
@@ -9,7 +9,7 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
 {
     public class MultiplayerResultsScreen : PlaylistsResultsScreen
     {
-        public MultiplayerResultsScreen(ScoreInfo score, int roomId, PlaylistItem playlistItem)
+        public MultiplayerResultsScreen(ScoreInfo score, long roomId, PlaylistItem playlistItem)
             : base(score, roomId, playlistItem, false, false)
         {
         }
diff --git a/osu.Game/Screens/OnlinePlay/OnlinePlayComposite.cs b/osu.Game/Screens/OnlinePlay/OnlinePlayComposite.cs
index b2f3e4a1d9..edae4aeec5 100644
--- a/osu.Game/Screens/OnlinePlay/OnlinePlayComposite.cs
+++ b/osu.Game/Screens/OnlinePlay/OnlinePlayComposite.cs
@@ -13,7 +13,7 @@ namespace osu.Game.Screens.OnlinePlay
     public class OnlinePlayComposite : CompositeDrawable
     {
         [Resolved(typeof(Room))]
-        protected Bindable<int?> RoomID { get; private set; }
+        protected Bindable<long?> RoomID { get; private set; }
 
         [Resolved(typeof(Room), nameof(Room.Name))]
         protected Bindable<string> RoomName { get; private set; }
@@ -42,6 +42,9 @@ namespace osu.Game.Screens.OnlinePlay
         [Resolved(typeof(Room))]
         protected Bindable<int?> MaxAttempts { get; private set; }
 
+        [Resolved(typeof(Room))]
+        public Bindable<PlaylistAggregateScore> UserScore { get; private set; }
+
         [Resolved(typeof(Room))]
         protected Bindable<DateTimeOffset?> EndDate { get; private set; }
 
diff --git a/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsPlayer.cs b/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsPlayer.cs
index 38eae2346a..ddc88261f7 100644
--- a/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsPlayer.cs
+++ b/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsPlayer.cs
@@ -24,7 +24,7 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
         public Action Exited;
 
         [Resolved(typeof(Room), nameof(Room.RoomID))]
-        protected Bindable<int?> RoomId { get; private set; }
+        protected Bindable<long?> RoomId { get; private set; }
 
         protected readonly PlaylistItem PlaylistItem;
 
diff --git a/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsResultsScreen.cs b/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsResultsScreen.cs
index e13c8a9f82..2b252f9db7 100644
--- a/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsResultsScreen.cs
+++ b/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsResultsScreen.cs
@@ -19,7 +19,7 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
 {
     public class PlaylistsResultsScreen : ResultsScreen
     {
-        private readonly int roomId;
+        private readonly long roomId;
         private readonly PlaylistItem playlistItem;
 
         protected LoadingSpinner LeftSpinner { get; private set; }
@@ -32,7 +32,7 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
         [Resolved]
         private IAPIProvider api { get; set; }
 
-        public PlaylistsResultsScreen(ScoreInfo score, int roomId, PlaylistItem playlistItem, bool allowRetry, bool allowWatchingReplay = true)
+        public PlaylistsResultsScreen(ScoreInfo score, long roomId, PlaylistItem playlistItem, bool allowRetry, bool allowWatchingReplay = true)
             : base(score, allowRetry, allowWatchingReplay)
         {
             this.roomId = roomId;
diff --git a/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsRoomSubScreen.cs b/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsRoomSubScreen.cs
index 31c441bcd2..694d804f6d 100644
--- a/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsRoomSubScreen.cs
+++ b/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsRoomSubScreen.cs
@@ -27,7 +27,7 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
         public override string ShortTitle => "playlist";
 
         [Resolved(typeof(Room), nameof(Room.RoomID))]
-        private Bindable<int?> roomId { get; set; }
+        private Bindable<long?> roomId { get; set; }
 
         private MatchSettingsOverlay settingsOverlay;
         private MatchLeaderboard leaderboard;
diff --git a/osu.Game/Screens/Play/HUD/ModDisplay.cs b/osu.Game/Screens/Play/HUD/ModDisplay.cs
index 68d019bf71..cffdb21fb8 100644
--- a/osu.Game/Screens/Play/HUD/ModDisplay.cs
+++ b/osu.Game/Screens/Play/HUD/ModDisplay.cs
@@ -72,19 +72,6 @@ namespace osu.Game.Screens.Play.HUD
                     }
                 },
             };
-
-            Current.ValueChanged += mods =>
-            {
-                iconsContainer.Clear();
-
-                foreach (Mod mod in mods.NewValue)
-                {
-                    iconsContainer.Add(new ModIcon(mod) { Scale = new Vector2(0.6f) });
-                }
-
-                if (IsLoaded)
-                    appearTransform();
-            };
         }
 
         protected override void Dispose(bool isDisposing)
@@ -97,7 +84,19 @@ namespace osu.Game.Screens.Play.HUD
         {
             base.LoadComplete();
 
-            appearTransform();
+            Current.BindValueChanged(mods =>
+            {
+                iconsContainer.Clear();
+
+                if (mods.NewValue != null)
+                {
+                    foreach (Mod mod in mods.NewValue)
+                        iconsContainer.Add(new ModIcon(mod) { Scale = new Vector2(0.6f) });
+
+                    appearTransform();
+                }
+            }, true);
+
             iconsContainer.FadeInFromZero(fade_duration, Easing.OutQuint);
         }
 
diff --git a/osu.Game/Screens/Select/Carousel/CarouselHeader.cs b/osu.Game/Screens/Select/Carousel/CarouselHeader.cs
index 947334c747..2fbf64de29 100644
--- a/osu.Game/Screens/Select/Carousel/CarouselHeader.cs
+++ b/osu.Game/Screens/Select/Carousel/CarouselHeader.cs
@@ -25,8 +25,13 @@ namespace osu.Game.Screens.Select.Carousel
 
         public readonly Bindable<CarouselItemState> State = new Bindable<CarouselItemState>(CarouselItemState.NotSelected);
 
+        private readonly HoverLayer hoverLayer;
+
         protected override Container<Drawable> Content { get; } = new Container { RelativeSizeAxes = Axes.Both };
 
+        private const float corner_radius = 10;
+        private const float border_thickness = 2.5f;
+
         public CarouselHeader()
         {
             RelativeSizeAxes = Axes.X;
@@ -36,12 +41,12 @@ namespace osu.Game.Screens.Select.Carousel
             {
                 RelativeSizeAxes = Axes.Both,
                 Masking = true,
-                CornerRadius = 10,
+                CornerRadius = corner_radius,
                 BorderColour = new Color4(221, 255, 255, 255),
                 Children = new Drawable[]
                 {
                     Content,
-                    new HoverLayer()
+                    hoverLayer = new HoverLayer()
                 }
             };
         }
@@ -59,6 +64,8 @@ namespace osu.Game.Screens.Select.Carousel
             {
                 case CarouselItemState.Collapsed:
                 case CarouselItemState.NotSelected:
+                    hoverLayer.InsetForBorder = false;
+
                     BorderContainer.BorderThickness = 0;
                     BorderContainer.EdgeEffect = new EdgeEffectParameters
                     {
@@ -70,7 +77,9 @@ namespace osu.Game.Screens.Select.Carousel
                     break;
 
                 case CarouselItemState.Selected:
-                    BorderContainer.BorderThickness = 2.5f;
+                    hoverLayer.InsetForBorder = true;
+
+                    BorderContainer.BorderThickness = border_thickness;
                     BorderContainer.EdgeEffect = new EdgeEffectParameters
                     {
                         Type = EdgeEffectType.Glow,
@@ -107,6 +116,26 @@ namespace osu.Game.Screens.Select.Carousel
                 sampleHover = audio.Samples.Get("SongSelect/song-ping");
             }
 
+            public bool InsetForBorder
+            {
+                set
+                {
+                    if (value)
+                    {
+                        // apply same border as above to avoid applying additive overlay to it (and blowing out the colour).
+                        Masking = true;
+                        CornerRadius = corner_radius;
+                        BorderThickness = border_thickness;
+                    }
+                    else
+                    {
+                        BorderThickness = 0;
+                        CornerRadius = 0;
+                        Masking = false;
+                    }
+                }
+            }
+
             protected override bool OnHover(HoverEvent e)
             {
                 box.FadeIn(100, Easing.OutQuint);
diff --git a/osu.Game/Screens/Select/FilterControl.cs b/osu.Game/Screens/Select/FilterControl.cs
index 952a5d1eaa..eafd8a87d1 100644
--- a/osu.Game/Screens/Select/FilterControl.cs
+++ b/osu.Game/Screens/Select/FilterControl.cs
@@ -44,7 +44,7 @@ namespace osu.Game.Screens.Select
                 Sort = sortMode.Value,
                 AllowConvertedBeatmaps = showConverted.Value,
                 Ruleset = ruleset.Value,
-                Collection = collectionDropdown?.Current.Value.Collection
+                Collection = collectionDropdown?.Current.Value?.Collection
             };
 
             if (!minimumStars.IsDefault)
diff --git a/osu.Game/Screens/Select/SongSelect.cs b/osu.Game/Screens/Select/SongSelect.cs
index edbab083cd..b7f7c40539 100644
--- a/osu.Game/Screens/Select/SongSelect.cs
+++ b/osu.Game/Screens/Select/SongSelect.cs
@@ -648,8 +648,9 @@ namespace osu.Game.Screens.Select
         {
             Debug.Assert(!isHandlingLooping);
 
-            music.CurrentTrack.Looping = isHandlingLooping = true;
+            isHandlingLooping = true;
 
+            ensureTrackLooping(Beatmap.Value, TrackChangeDirection.None);
             music.TrackChanged += ensureTrackLooping;
         }
 
@@ -665,7 +666,7 @@ namespace osu.Game.Screens.Select
         }
 
         private void ensureTrackLooping(WorkingBeatmap beatmap, TrackChangeDirection changeDirection)
-            => music.CurrentTrack.Looping = true;
+            => beatmap.PrepareTrackForPreviewLooping();
 
         public override bool OnBackButton()
         {
@@ -719,8 +720,6 @@ namespace osu.Game.Screens.Select
 
             bool isNewTrack = !lastTrack.TryGetTarget(out var last) || last != track;
 
-            track.RestartPoint = Beatmap.Value.Metadata.PreviewTime;
-
             if (!track.IsRunning && (music.UserPauseRequested != true || isNewTrack))
                 music.Play(true);