Merge pull request #94 from Zingabopp/dev

Goobwabber · web-flow · commit 897f07210370 · 2021-02-15T13:53:36.000-05:00
Bug Fixes
diff --git a/MultiplayerExtensions/Beatmaps/PreviewBeatmapStub.cs b/MultiplayerExtensions/Beatmaps/PreviewBeatmapStub.cs
@@ -91,9 +91,9 @@ public PreviewBeatmapStub(PreviewBeatmapPacket packet)
             _rawCoverTask = Task.FromResult(packet.coverImage);
         }
 
-        public PreviewBeatmapStub(Beatmap bm)
+        public PreviewBeatmapStub(string levelID, Beatmap bm)
         {
-            this.levelID = bm.ID;
+            this.levelID = levelID;
             this.levelHash = bm.Hash;
             
             this.beatmap = bm;
diff --git a/MultiplayerExtensions/Environments/LobbyPlaceManager.cs b/MultiplayerExtensions/Environments/LobbyPlaceManager.cs
@@ -53,7 +53,10 @@ public void SetCenterScreenScale()
 			float angleBetweenPlayersWithEvenAdjustment = MultiplayerPlayerPlacement.GetAngleBetweenPlayersWithEvenAdjustment(_lobbyStateDataModel.maxPartySize, MultiplayerPlayerLayout.Circle);
 			float outerCircleRadius = Mathf.Max(MultiplayerPlayerPlacement.GetOuterCircleRadius(angleBetweenPlayersWithEvenAdjustment, innerCircleRadius), minOuterCircleRadius);
 			float scaleRatio = outerCircleRadius / minOuterCircleRadius;
-			MultiplayerLobbyCenterStageManager centerscreen = Resources.FindObjectsOfTypeAll<MultiplayerLobbyCenterStageManager>().First();
+			MultiplayerLobbyCenterStageManager[] centerscreens = Resources.FindObjectsOfTypeAll<MultiplayerLobbyCenterStageManager>();
+			if (centerscreens.Length == 0)
+				return;
+			MultiplayerLobbyCenterStageManager centerscreen = centerscreens.First();
 			centerscreen.transform.localScale = new Vector3(scaleRatio, scaleRatio, scaleRatio);
 		}
 
diff --git a/MultiplayerExtensions/HarmonyPatches/CustomSongsPatches.cs b/MultiplayerExtensions/HarmonyPatches/CustomSongsPatches.cs
@@ -8,7 +8,7 @@
 namespace MultiplayerExtensions.HarmonyPatches
 {
     [HarmonyPatch(typeof(MultiplayerLevelSelectionFlowCoordinator), "enableCustomLevels", MethodType.Getter)]
-    public class EnableCustomLevelsPatch
+    internal class EnableCustomLevelsPatch
     {
         /// <summary>
         /// Overrides getter for <see cref="MultiplayerLevelSelectionFlowCoordinator.enableCustomLevels"/>
@@ -20,8 +20,20 @@ static bool Prefix(ref bool __result)
         }
     }
 
+    [HarmonyPatch(typeof(HostLobbySetupViewController), "SetPlayersMissingLevelText", MethodType.Normal)]
+    internal class MissingLevelStartPatch
+    {
+        /// <summary>
+        /// Disables starting of game if not all players have song.
+        /// </summary>
+        static void Prefix(HostLobbySetupViewController __instance, string playersMissingLevelText)
+        {
+            __instance.SetStartGameEnabled(playersMissingLevelText == null, HostLobbySetupViewController.CannotStartGameReason.None);
+        }
+    }
+
     [HarmonyPatch(typeof(NetworkPlayerEntitlementChecker), "GetEntitlementStatus", MethodType.Normal)]
-    public class CustomLevelEntitlementPatch
+    internal class CustomLevelEntitlementPatch
     {
         /// <summary>
         /// Changes the return value of the entitlement checker if it is a custom song.
@@ -32,7 +44,7 @@ static bool Prefix(string levelId, ref Task<EntitlementsStatus> __result)
             if (hash == null)
                 return true;
 
-            if (SongCore.Loader.GetLevelByHash(hash) != null)
+            if (SongCore.Collections.songWithHashPresent(hash))
                 __result = Task.FromResult(EntitlementsStatus.Ok);
             else
                 __result = Plugin.BeatSaver.Hash(hash).ContinueWith<EntitlementsStatus>(r =>
@@ -48,7 +60,7 @@ static bool Prefix(string levelId, ref Task<EntitlementsStatus> __result)
     }
 
     [HarmonyPatch(typeof(NetworkPlayerEntitlementChecker), "GetPlayerLevelEntitlementsAsync", MethodType.Normal)]
-    public class StartGameLevelEntitlementPatch
+    internal class StartGameLevelEntitlementPatch
     {
         /// <summary>
         /// Changes the return value if it returns 'NotDownloaded' so that the host can start the game.
diff --git a/MultiplayerExtensions/HarmonyPatches/HarmonyManager.cs b/MultiplayerExtensions/HarmonyPatches/HarmonyManager.cs
@@ -40,6 +40,7 @@ static HarmonyManager()
             AddDefaultPatch<PlayerPlacementAnglePatch>();
             AddDefaultPatch<IncreaseMaxPlayersClampPatch>();
             AddDefaultPatch<IncreaseMaxPlayersPatch>();
+            AddDefaultPatch<MissingLevelStartPatch>();
             //AddDefaultPatch<RemoveByteLimitPatch>(); (doesn't support generics)
         }
 
diff --git a/MultiplayerExtensions/HarmonyPatches/NetworkingPatches.cs b/MultiplayerExtensions/HarmonyPatches/NetworkingPatches.cs
@@ -1,6 +1,8 @@
 ﻿using HarmonyLib;
+using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Reflection;
 using System.Reflection.Emit;
 using UnityEngine;
 
@@ -57,24 +59,27 @@ internal static bool Prefix()
 		}
     }
 
-	[HarmonyPatch(typeof(ConnectedPlayerManager), "FlushUnreliableQueue", MethodType.Normal)]
+	[HarmonyPatch(typeof(ConnectedPlayerManager), "PollUpdate", MethodType.Normal)]
 	internal class UpdateUnreliableFrequencyPatch
 	{
-		private static float nextTime = 0f;
-		private static float frequency = 0.1f;
+		private static readonly MethodInfo _updateUnreliableMethod = typeof(ConnectedPlayerManager).GetMethod("FlushUnreliableQueue", BindingFlags.NonPublic | BindingFlags.Instance);
 
-		internal static bool Prefix()
+		internal static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
 		{
-			if (Time.time > nextTime)
+			var codes = instructions.ToList();
+			for (int i = 0; i < codes.Count; i++)
 			{
-				nextTime = Time.time + frequency;
-				return true;
+				if (codes[i].opcode == OpCodes.Ldarg_0 && codes[i+1].Calls(_updateUnreliableMethod))
+                {
+					codes.RemoveRange(i, 2);
+                }
 			}
-			return false;
+
+			return codes.AsEnumerable();
 		}
 	}
 
-	//Make this work with harmony manager
+	// TODO: Make this work with harmony manager
 	[HarmonyPatch(typeof(ConnectedPlayerManager), "SendUnreliable", MethodType.Normal)]
 	internal class RemoveByteLimitPatch
     {
diff --git a/MultiplayerExtensions/Installers/MPCoreInstaller.cs b/MultiplayerExtensions/Installers/MPCoreInstaller.cs
@@ -5,7 +5,7 @@
 
 namespace MultiplayerExtensions.Installers
 {
-	class MultiplayerInstaller : MonoInstaller
+	class MPCoreInstaller : MonoInstaller
 	{
 		public HarmonyPatchInfo? lobbyPlayerDataPatch;
 		public HarmonyPatchInfo? levelLoaderPatch;
diff --git a/MultiplayerExtensions/Installers/MPMenuInstaller.cs b/MultiplayerExtensions/Installers/MPMenuInstaller.cs
@@ -2,11 +2,12 @@
 using MultiplayerExtensions.Environments;
 using MultiplayerExtensions.OverrideClasses;
 using MultiplayerExtensions.UI;
+using UnityEngine;
 using Zenject;
 
 namespace MultiplayerExtensions.Installers
 {
-    class InterfaceInstaller : MonoInstaller
+    class MPMenuInstaller : MonoInstaller
     {
         public override void InstallBindings()
         {
@@ -33,9 +34,11 @@ public override void Start()
             ServerPlayerListController playerListController = Container.Resolve<ServerPlayerListController>();
             GameServerPlayersTableView playersTableView = playerListController.GetField<GameServerPlayersTableView, ServerPlayerListController>("_gameServerPlayersTableView");
             GameServerPlayerTableCell playerTableCell = playersTableView.GetField<GameServerPlayerTableCell, GameServerPlayersTableView>("_gameServerPlayerCellPrefab");
-            PlayerTableCellStub playerTableCellStub = playerTableCell.gameObject.AddComponent<PlayerTableCellStub>();
-            playerTableCellStub.Construct(playerTableCell);
-            Destroy(playerTableCell.GetComponent<GameServerPlayerTableCell>());
+            GameServerPlayerTableCell newPlayerTableCell = GameObject.Instantiate(playerTableCell);
+            newPlayerTableCell.gameObject.SetActive(false);
+            PlayerTableCellStub playerTableCellStub = newPlayerTableCell.gameObject.AddComponent<PlayerTableCellStub>();
+            playerTableCellStub.Construct(newPlayerTableCell);
+            Destroy(newPlayerTableCell.GetComponent<GameServerPlayerTableCell>());
             playersTableView.SetField<GameServerPlayersTableView, GameServerPlayerTableCell>("_gameServerPlayerCellPrefab", playerTableCellStub);
         }
     }
diff --git a/MultiplayerExtensions/MultiplayerExtensions.csproj b/MultiplayerExtensions/MultiplayerExtensions.csproj
@@ -4,7 +4,7 @@
     <OutputType>Library</OutputType>
     <AppDesignerFolder>Properties</AppDesignerFolder>
     <AssemblyName>MultiplayerExtensions</AssemblyName>
-    <AssemblyVersion>0.4.4</AssemblyVersion>
+    <AssemblyVersion>0.4.5</AssemblyVersion>
     <TargetFramework>net472</TargetFramework>
     <DebugSymbols>true</DebugSymbols>
     <DebugType>portable</DebugType>
diff --git a/MultiplayerExtensions/OverrideClasses/LevelLoaderStub.cs b/MultiplayerExtensions/OverrideClasses/LevelLoaderStub.cs
@@ -10,7 +10,7 @@ public override void LoadLevel(BeatmapIdentifierNetSerializable beatmapId, Gamep
         {
             string? levelId = beatmapId.levelID;
             string? hash = Utilities.Utils.LevelIdToHash(beatmapId.levelID);
-            if (SongCore.Loader.GetLevelById(levelId) != null || hash == null)
+            if (SongCore.Collections.songWithHashPresent(hash) || hash == null)
             {
                 Plugin.Log?.Debug($"(SongLoader) Level with ID '{levelId}' already exists.");
                 base.LoadLevel(beatmapId, gameplayModifiers, initialStartTime);
diff --git a/MultiplayerExtensions/OverrideClasses/PlayerTableCellStub.cs b/MultiplayerExtensions/OverrideClasses/PlayerTableCellStub.cs
@@ -72,6 +72,8 @@ public override void Awake() {
 
         public override void SetData(IConnectedPlayer connectedPlayer, ILobbyPlayerDataModel playerDataModel, bool isHost, Task<AdditionalContentModel.EntitlementStatus> getLevelEntitlementTask)
         {
+            if (getLevelEntitlementTask != null)
+                getLevelEntitlementTask = getLevelEntitlementTask.ContinueWith<AdditionalContentModel.EntitlementStatus>(r => AdditionalContentModel.EntitlementStatus.Owned);
             base.SetData(connectedPlayer, playerDataModel, isHost, getLevelEntitlementTask);
             GetLevelEntitlement(connectedPlayer);
             lastPlayer = connectedPlayer;
@@ -84,12 +86,18 @@ private async void GetLevelEntitlement(IConnectedPlayer player)
             entitlementCts = new CancellationTokenSource();
 
             string? levelId = _playersDataModel.GetPlayerBeatmapLevel(_playersDataModel.hostUserId)?.levelID;
-            if (levelId == null)
+            if (levelId == null) 
                 return;
 
             lastLevelId = levelId;
-            EntitlementsStatus entitlement = player.isMe ? await _entitlementChecker.GetEntitlementStatus(levelId) : await _entitlementChecker.GetTcsTaskCanPlayerPlayLevel(player, levelId, entitlementCts.Token, out _);
-            SetLevelEntitlement(player, entitlement);
+
+            bool needsRpc = false;
+            Task<EntitlementsStatus> entitlement = player.isMe ? 
+                _entitlementChecker.GetEntitlementStatus(levelId) : 
+                _entitlementChecker.GetTcsTaskCanPlayerPlayLevel(player, levelId, entitlementCts.Token, out needsRpc);
+            if (needsRpc)
+                _menuRpcManager.GetIsEntitledToLevel(levelId);
+            SetLevelEntitlement(player, await entitlement);
         }
 
         private void SetLevelEntitlement(IConnectedPlayer player, EntitlementsStatus status)
diff --git a/MultiplayerExtensions/OverrideClasses/PlayersDataModelStub.cs b/MultiplayerExtensions/OverrideClasses/PlayersDataModelStub.cs
@@ -80,7 +80,7 @@ public override void HandleMenuRpcManagerClearBeatmap(string userId)
         public async override void HandleMenuRpcManagerGetSelectedBeatmap(string userId)
         {
             ILobbyPlayerDataModel lobbyPlayerDataModel = this.GetLobbyPlayerDataModel(this.localUserId);
-            if (_multiplayerSessionManager.GetPlayerByUserId(userId).HasState("modded") && lobbyPlayerDataModel?.beatmapLevel is PreviewBeatmapStub preview)
+            if (lobbyPlayerDataModel != null && MPState.CurrentGameType != MultiplayerGameType.QuickPlay && _multiplayerSessionManager.GetPlayerByUserId(userId).HasState("modded") && lobbyPlayerDataModel?.beatmapLevel is PreviewBeatmapStub preview)
                 _packetManager.Send(await PreviewBeatmapPacket.FromPreview(preview, lobbyPlayerDataModel.beatmapCharacteristic.serializedName, lobbyPlayerDataModel.beatmapDifficulty));
             else if (lobbyPlayerDataModel != null && lobbyPlayerDataModel.beatmapLevel != null)
                 this._menuRpcManager.SelectBeatmap(new BeatmapIdentifierNetSerializable(lobbyPlayerDataModel.beatmapLevel.levelID, lobbyPlayerDataModel.beatmapCharacteristic.serializedName, lobbyPlayerDataModel.beatmapDifficulty));
@@ -109,7 +109,7 @@ public async override void HandleMenuRpcManagerSelectedBeatmap(string userId, Be
                     if (localPreview != null)
                         preview = new PreviewBeatmapStub(hash, localPreview);
                     if (preview == null)
-                        preview = await FetchBeatSaverPreview(hash);
+                        preview = await FetchBeatSaverPreview(beatmapId.levelID, hash);
                     HMMainThreadDispatcher.instance.Enqueue(() => base.SetPlayerBeatmapLevel(userId, preview, beatmapId.difficulty, characteristic));
                 }
             }
@@ -123,7 +123,7 @@ public async override void HandleMenuRpcManagerSelectedBeatmap(string userId, Be
         public async new void SetLocalPlayerBeatmapLevel(string levelId, BeatmapDifficulty beatmapDifficulty, BeatmapCharacteristicSO characteristic)
         {
             string? hash = Utilities.Utils.LevelIdToHash(levelId);
-            Plugin.Log?.Debug($"Local user selected song '{hash}'.");
+            Plugin.Log?.Debug($"Local user selected song '{hash ?? levelId}'.");
             if (hash != null)
             {
                 if (_playersData.Values.Any(playerData => playerData.beatmapLevel?.levelID == levelId))
@@ -139,7 +139,7 @@ public async override void HandleMenuRpcManagerSelectedBeatmap(string userId, Be
                     if (localPreview != null)
                         preview = new PreviewBeatmapStub(hash, localPreview);
                     if (preview == null)
-                        preview = await FetchBeatSaverPreview(hash);
+                        preview = await FetchBeatSaverPreview(levelId, hash);
 
                     HMMainThreadDispatcher.instance.Enqueue(() => base.SetPlayerBeatmapLevel(base.localUserId, preview, beatmapDifficulty, characteristic));
                     _packetManager.Send(await PreviewBeatmapPacket.FromPreview(preview, characteristic.serializedName, beatmapDifficulty));
@@ -195,12 +195,12 @@ private void OnSelectedBeatmap(string userId, BeatmapIdentifierNetSerializable?
         /// <summary>
         /// Creates a preview from a BeatSaver request.
         /// </summary>
-        public async Task<PreviewBeatmapStub?> FetchBeatSaverPreview(string hash)
+        public async Task<PreviewBeatmapStub?> FetchBeatSaverPreview(string levelID, string hash)
         {
             try
             {
                 Beatmap bm = await Plugin.BeatSaver.Hash(hash);
-                return new PreviewBeatmapStub(bm);
+                return new PreviewBeatmapStub(levelID, bm);
             }
             catch(Exception ex)
             {
diff --git a/MultiplayerExtensions/Plugin.cs b/MultiplayerExtensions/Plugin.cs
@@ -43,8 +43,8 @@ public Plugin(IPALogger logger, Config conf, Zenjector zenjector, PluginMetadata
             PluginMetadata = pluginMetadata;
             Log = logger;
             Config = conf.Generated<PluginConfig>();
-            zenjector.OnApp<MultiplayerInstaller>();
-            zenjector.OnMenu<InterfaceInstaller>();
+            zenjector.OnApp<MPCoreInstaller>();
+            zenjector.OnMenu<MPMenuInstaller>();
             HttpOptions options = new HttpOptions("MultiplayerExtensions", new Version(pluginMetadata.Version.ToString()));
             BeatSaver = new BeatSaver(options);
         }
diff --git a/MultiplayerExtensions/UI/ClientLobbySetupPanel.bsml b/MultiplayerExtensions/UI/ClientLobbySetupPanel.bsml
@@ -1,5 +1,5 @@
 <vertical>
-  <horizontal pad-top='30'>
+  <horizontal pad-top='0'>
     <vertical min-width='45' horizontal-fit='MinSize'>
       <toggle-setting id='CustomSongsToggle' value='CustomSongs' on-change='SetCustomSongs' text='Custom Songs' interactable='false' hover-hint='Whether the host has custom songs enabled'></toggle-setting>
       <toggle-setting id='EnforceModsToggle' value='EnforceMods' on-change='SetEnforceMods' text='Enforce Mods' interactable='false' hover-hint='Whether players without MultiplayerExtensions will be kicked'></toggle-setting>
diff --git a/MultiplayerExtensions/UI/HostLobbySetupPanel.bsml b/MultiplayerExtensions/UI/HostLobbySetupPanel.bsml
@@ -1,5 +1,5 @@
 <vertical>
-  <horizontal pad-top='30'>
+  <horizontal pad-top='0'>
     <vertical min-width='45' horizontal-fit='MinSize'>
       <toggle-setting id='CustomSongsToggle' value='CustomSongs' on-change='SetCustomSongs' text='Custom Songs' hover-hint='Toggles custom songs for all players'></toggle-setting>
       <toggle-setting id='EnforceModsToggle' value='EnforceMods' on-change='SetEnforceMods' text='Enforce Mods' hover-hint='Toggles kicking players without MultiplayerExtensions'></toggle-setting>
diff --git a/MultiplayerExtensions/manifest.json b/MultiplayerExtensions/manifest.json
@@ -3,7 +3,7 @@
   "id": "MultiplayerExtensions",
   "name": "MultiplayerExtensions",
   "author": "Zingabopp and Goobwabber",
-  "version": "0.4.4",
+  "version": "0.4.5",
   "description": "Expands the functionality of Beat Saber Multiplayer.",
   "gameVersion": "1.13.2",
   "dependsOn": {

Original file line number	Diff line number	Diff line change
`@@ -91,9 +91,9 @@ public PreviewBeatmapStub(PreviewBeatmapPacket packet)`
`91`	`91`	`_rawCoverTask = Task.FromResult(packet.coverImage);`
`92`	`92`	`}`
`93`	`93`
`94`		`- public PreviewBeatmapStub(Beatmap bm)`
	`94`	`+ public PreviewBeatmapStub(string levelID, Beatmap bm)`
`95`	`95`	`{`
`96`		`- this.levelID = bm.ID;`
	`96`	`+ this.levelID = levelID;`
`97`	`97`	`this.levelHash = bm.Hash;`
`98`	`98`
`99`	`99`	`this.beatmap = bm;`
Original file line number	Diff line number	Diff line change
`@@ -40,6 +40,7 @@ static HarmonyManager()`
`40`	`40`	`AddDefaultPatch<PlayerPlacementAnglePatch>();`
`41`	`41`	`AddDefaultPatch<IncreaseMaxPlayersClampPatch>();`
`42`	`42`	`AddDefaultPatch<IncreaseMaxPlayersPatch>();`
	`43`	`+ AddDefaultPatch<MissingLevelStartPatch>();`
`43`	`44`	`//AddDefaultPatch<RemoveByteLimitPatch>(); (doesn't support generics)`
`44`	`45`	`}`
`45`	`46`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,8 @@`
`1`	`1`	`using HarmonyLib;`
	`2`	`+using System;`
`2`	`3`	`using System.Collections.Generic;`
`3`	`4`	`using System.Linq;`
	`5`	`+using System.Reflection;`
`4`	`6`	`using System.Reflection.Emit;`
`5`	`7`	`using UnityEngine;`
`6`	`8`
`@@ -57,24 +59,27 @@ internal static bool Prefix()`
`57`	`59`	`}`
`58`	`60`	`}`
`59`	`61`
`60`		`- [HarmonyPatch(typeof(ConnectedPlayerManager), "FlushUnreliableQueue", MethodType.Normal)]`
	`62`	`+ [HarmonyPatch(typeof(ConnectedPlayerManager), "PollUpdate", MethodType.Normal)]`
`61`	`63`	`internal class UpdateUnreliableFrequencyPatch`
`62`	`64`	`{`
`63`		`- private static float nextTime = 0f;`
`64`		`- private static float frequency = 0.1f;`
	`65`	`+ private static readonly MethodInfo _updateUnreliableMethod = typeof(ConnectedPlayerManager).GetMethod("FlushUnreliableQueue", BindingFlags.NonPublic \| BindingFlags.Instance);`
`65`	`66`
`66`		`- internal static bool Prefix()`
	`67`	`+ internal static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)`
`67`	`68`	`{`
`68`		`- if (Time.time > nextTime)`
	`69`	`+ var codes = instructions.ToList();`
	`70`	`+ for (int i = 0; i < codes.Count; i++)`
`69`	`71`	`{`
`70`		`- nextTime = Time.time + frequency;`
`71`		`- return true;`
	`72`	`+ if (codes[i].opcode == OpCodes.Ldarg_0 && codes[i+1].Calls(_updateUnreliableMethod))`
	`73`	`+ {`
	`74`	`+ codes.RemoveRange(i, 2);`
	`75`	`+ }`
`72`	`76`	`}`
`73`		`- return false;`
	`77`	`+`
	`78`	`+ return codes.AsEnumerable();`
`74`	`79`	`}`
`75`	`80`	`}`
`76`	`81`
`77`		`- //Make this work with harmony manager`
	`82`	`+ // TODO: Make this work with harmony manager`
`78`	`83`	`[HarmonyPatch(typeof(ConnectedPlayerManager), "SendUnreliable", MethodType.Normal)]`
`79`	`84`	`internal class RemoveByteLimitPatch`
`80`	`85`	`{`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@`
`5`	`5`
`6`	`6`	`namespace MultiplayerExtensions.Installers`
`7`	`7`	`{`
`8`		`- class MultiplayerInstaller : MonoInstaller`
	`8`	`+ class MPCoreInstaller : MonoInstaller`
`9`	`9`	`{`
`10`	`10`	`public HarmonyPatchInfo? lobbyPlayerDataPatch;`
`11`	`11`	`public HarmonyPatchInfo? levelLoaderPatch;`
Original file line number	Diff line number	Diff line change
`@@ -2,11 +2,12 @@`
`2`	`2`	`using MultiplayerExtensions.Environments;`
`3`	`3`	`using MultiplayerExtensions.OverrideClasses;`
`4`	`4`	`using MultiplayerExtensions.UI;`
	`5`	`+using UnityEngine;`
`5`	`6`	`using Zenject;`
`6`	`7`
`7`	`8`	`namespace MultiplayerExtensions.Installers`
`8`	`9`	`{`
`9`		`- class InterfaceInstaller : MonoInstaller`
	`10`	`+ class MPMenuInstaller : MonoInstaller`
`10`	`11`	`{`
`11`	`12`	`public override void InstallBindings()`
`12`	`13`	`{`
`@@ -33,9 +34,11 @@ public override void Start()`
`33`	`34`	`ServerPlayerListController playerListController = Container.Resolve<ServerPlayerListController>();`
`34`	`35`	`GameServerPlayersTableView playersTableView = playerListController.GetField<GameServerPlayersTableView, ServerPlayerListController>("_gameServerPlayersTableView");`
`35`	`36`	`GameServerPlayerTableCell playerTableCell = playersTableView.GetField<GameServerPlayerTableCell, GameServerPlayersTableView>("_gameServerPlayerCellPrefab");`
`36`		`- PlayerTableCellStub playerTableCellStub = playerTableCell.gameObject.AddComponent<PlayerTableCellStub>();`
`37`		`- playerTableCellStub.Construct(playerTableCell);`
`38`		`- Destroy(playerTableCell.GetComponent<GameServerPlayerTableCell>());`
	`37`	`+ GameServerPlayerTableCell newPlayerTableCell = GameObject.Instantiate(playerTableCell);`
	`38`	`+ newPlayerTableCell.gameObject.SetActive(false);`
	`39`	`+ PlayerTableCellStub playerTableCellStub = newPlayerTableCell.gameObject.AddComponent<PlayerTableCellStub>();`
	`40`	`+ playerTableCellStub.Construct(newPlayerTableCell);`
	`41`	`+ Destroy(newPlayerTableCell.GetComponent<GameServerPlayerTableCell>());`
`39`	`42`	`playersTableView.SetField<GameServerPlayersTableView, GameServerPlayerTableCell>("_gameServerPlayerCellPrefab", playerTableCellStub);`
`40`	`43`	`}`
`41`	`44`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ public override void LoadLevel(BeatmapIdentifierNetSerializable beatmapId, Gamep`
`10`	`10`	`{`
`11`	`11`	`string? levelId = beatmapId.levelID;`
`12`	`12`	`string? hash = Utilities.Utils.LevelIdToHash(beatmapId.levelID);`
`13`		`- if (SongCore.Loader.GetLevelById(levelId) != null \|\| hash == null)`
	`13`	`+ if (SongCore.Collections.songWithHashPresent(hash) \|\| hash == null)`
`14`	`14`	`{`
`15`	`15`	`Plugin.Log?.Debug($"(SongLoader) Level with ID '{levelId}' already exists.");`
`16`	`16`	`base.LoadLevel(beatmapId, gameplayModifiers, initialStartTime);`
Original file line number	Diff line number	Diff line change
`@@ -80,7 +80,7 @@ public override void HandleMenuRpcManagerClearBeatmap(string userId)`
`80`	`80`	`public async override void HandleMenuRpcManagerGetSelectedBeatmap(string userId)`
`81`	`81`	`{`
`82`	`82`	`ILobbyPlayerDataModel lobbyPlayerDataModel = this.GetLobbyPlayerDataModel(this.localUserId);`
`83`		`- if (_multiplayerSessionManager.GetPlayerByUserId(userId).HasState("modded") && lobbyPlayerDataModel?.beatmapLevel is PreviewBeatmapStub preview)`
	`83`	`+ if (lobbyPlayerDataModel != null && MPState.CurrentGameType != MultiplayerGameType.QuickPlay && _multiplayerSessionManager.GetPlayerByUserId(userId).HasState("modded") && lobbyPlayerDataModel?.beatmapLevel is PreviewBeatmapStub preview)`
`84`	`84`	`_packetManager.Send(await PreviewBeatmapPacket.FromPreview(preview, lobbyPlayerDataModel.beatmapCharacteristic.serializedName, lobbyPlayerDataModel.beatmapDifficulty));`
`85`	`85`	`else if (lobbyPlayerDataModel != null && lobbyPlayerDataModel.beatmapLevel != null)`
`86`	`86`	`this._menuRpcManager.SelectBeatmap(new BeatmapIdentifierNetSerializable(lobbyPlayerDataModel.beatmapLevel.levelID, lobbyPlayerDataModel.beatmapCharacteristic.serializedName, lobbyPlayerDataModel.beatmapDifficulty));`
`@@ -109,7 +109,7 @@ public async override void HandleMenuRpcManagerSelectedBeatmap(string userId, Be`
`109`	`109`	`if (localPreview != null)`
`110`	`110`	`preview = new PreviewBeatmapStub(hash, localPreview);`
`111`	`111`	`if (preview == null)`
`112`		`- preview = await FetchBeatSaverPreview(hash);`
	`112`	`+ preview = await FetchBeatSaverPreview(beatmapId.levelID, hash);`
`113`	`113`	`HMMainThreadDispatcher.instance.Enqueue(() => base.SetPlayerBeatmapLevel(userId, preview, beatmapId.difficulty, characteristic));`
`114`	`114`	`}`
`115`	`115`	`}`
`@@ -123,7 +123,7 @@ public async override void HandleMenuRpcManagerSelectedBeatmap(string userId, Be`
`123`	`123`	`public async new void SetLocalPlayerBeatmapLevel(string levelId, BeatmapDifficulty beatmapDifficulty, BeatmapCharacteristicSO characteristic)`
`124`	`124`	`{`
`125`	`125`	`string? hash = Utilities.Utils.LevelIdToHash(levelId);`
`126`		`- Plugin.Log?.Debug($"Local user selected song '{hash}'.");`
	`126`	`+ Plugin.Log?.Debug($"Local user selected song '{hash ?? levelId}'.");`
`127`	`127`	`if (hash != null)`
`128`	`128`	`{`
`129`	`129`	`if (_playersData.Values.Any(playerData => playerData.beatmapLevel?.levelID == levelId))`
`@@ -139,7 +139,7 @@ public async override void HandleMenuRpcManagerSelectedBeatmap(string userId, Be`
`139`	`139`	`if (localPreview != null)`
`140`	`140`	`preview = new PreviewBeatmapStub(hash, localPreview);`
`141`	`141`	`if (preview == null)`
`142`		`- preview = await FetchBeatSaverPreview(hash);`
	`142`	`+ preview = await FetchBeatSaverPreview(levelId, hash);`
`143`	`143`
`144`	`144`	`HMMainThreadDispatcher.instance.Enqueue(() => base.SetPlayerBeatmapLevel(base.localUserId, preview, beatmapDifficulty, characteristic));`
`145`	`145`	`_packetManager.Send(await PreviewBeatmapPacket.FromPreview(preview, characteristic.serializedName, beatmapDifficulty));`
`@@ -195,12 +195,12 @@ private void OnSelectedBeatmap(string userId, BeatmapIdentifierNetSerializable?`
`195`	`195`	`/// <summary>`
`196`	`196`	`/// Creates a preview from a BeatSaver request.`
`197`	`197`	`/// </summary>`
`198`		`- public async Task<PreviewBeatmapStub?> FetchBeatSaverPreview(string hash)`
	`198`	`+ public async Task<PreviewBeatmapStub?> FetchBeatSaverPreview(string levelID, string hash)`
`199`	`199`	`{`
`200`	`200`	`try`
`201`	`201`	`{`
`202`	`202`	`Beatmap bm = await Plugin.BeatSaver.Hash(hash);`
`203`		`- return new PreviewBeatmapStub(bm);`
	`203`	`+ return new PreviewBeatmapStub(levelID, bm);`
`204`	`204`	`}`
`205`	`205`	`catch(Exception ex)`
`206`	`206`	`{`