Merge pull request #90 from Zingabopp/dev

Improve networking / New BT support

MultiplayerExtensions/Environments/PlayerColorManager.cs → MultiplayerExtensions/Environments/LobbyEnvironmentManager.cs

@@ -1,19 +1,20 @@
 using MultiplayerExtensions.Packets;
 using MultiplayerExtensions.Sessions;
 using System;
+using System.Linq;
 using UnityEngine;
 using Zenject;
 
 namespace MultiplayerExtensions.Environments
 {
-    public class PlayerColorManager : IInitializable, IDisposable
+    public class LobbyEnvironmentManager : IInitializable, IDisposable
     {
         protected readonly PacketManager _packetManager;
         protected readonly IMultiplayerSessionManager _sessionManager;
         protected readonly LobbyPlaceManager _placeManager;
         protected readonly ExtendedPlayerManager _playerManager;
 
-        internal PlayerColorManager(PacketManager packetManager, IMultiplayerSessionManager sessionManager, LobbyPlaceManager placeManager, ExtendedPlayerManager playerManager)
+        internal LobbyEnvironmentManager(PacketManager packetManager, IMultiplayerSessionManager sessionManager, LobbyPlaceManager placeManager, ExtendedPlayerManager playerManager)
         {
             _packetManager = packetManager;
             _sessionManager = sessionManager;
@@ -37,6 +38,10 @@ public void Dispose()
 
         private void HandleLobbyEnvironmentLoaded(object sender, System.EventArgs e)
         {
+            MenuEnvironmentManager envManager = Resources.FindObjectsOfTypeAll<MenuEnvironmentManager>().First();
+            bool flag = _sessionManager.maxPlayerCount <= 30;
+            envManager.transform.Find("NearBuildingLeft").gameObject.SetActive(flag);
+            envManager.transform.Find("NearBuildingRight").gameObject.SetActive(flag);
             ReloadEnvironment();
         }
 

MultiplayerExtensions/HarmonyPatches/HarmonyManager.cs

@@ -23,7 +23,6 @@ internal static Harmony Harmony
 
         internal static readonly HashSet<HarmonyPatchInfo> AppliedPatches = new HashSet<HarmonyPatchInfo>();
         internal static readonly HashSet<HarmonyPatchInfo> DefaultPatches = new HashSet<HarmonyPatchInfo>();
-        internal static readonly Dictionary<HarmonyPatchInfo, string> DependentPatches = new Dictionary<HarmonyPatchInfo, string>();
 
         static HarmonyManager()
         {
@@ -36,6 +35,12 @@ static HarmonyManager()
             AddDefaultPatch<SetLobbyCodePatch>();
             AddDefaultPatch<LobbyEnvironmentLoadPatch>();
             AddDefaultPatch<StartGameLevelEntitlementPatch>();
+            AddDefaultPatch<UpdateReliableFrequencyPatch>();
+            AddDefaultPatch<UpdateUnreliableFrequencyPatch>();
+            AddDefaultPatch<PlayerPlacementAnglePatch>();
+            AddDefaultPatch<IncreaseMaxPlayersClampPatch>();
+            AddDefaultPatch<IncreaseMaxPlayersPatch>();
+            //AddDefaultPatch<RemoveByteLimitPatch>(); (doesn't support generics)
         }
 
         private static void AddDefaultPatch<T>() where T : class
@@ -92,12 +97,6 @@ internal static void ApplyDefaultPatches()
             Plugin.Log?.Debug($"Applying {patches.Length} Harmony patches.");
             for (int i = 0; i < patches.Length; i++)
                 ApplyPatch(patches[i]);
-
-            foreach (HarmonyPatchInfo patch in DependentPatches.Keys)
-            {
-                if (IPA.Loader.PluginManager.GetPluginFromId(DependentPatches[patch]) != null)
-                    ApplyPatch(patch);
-            }
         }
 
         internal static void UnpatchAll()

MultiplayerExtensions/HarmonyPatches/MaxPlayerPatches.cs

@@ -7,9 +7,9 @@
 namespace MultiplayerExtensions.HarmonyPatches
 {
     [HarmonyPatch(typeof(MultiplayerPlayerPlacement), "GetAngleBetweenPlayersWithEvenAdjustment", MethodType.Normal)]
-    class PlayerPlacementAnglePatch
+    internal class PlayerPlacementAnglePatch
     {
-        static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
+        internal static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
         {
             var codes = instructions.ToList();
             bool flag = true;
@@ -31,29 +31,31 @@ static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> inst
     }
 
     [HarmonyPatch(typeof(CreateServerFormController), "formData", MethodType.Getter)]
-    class IncreaseMaxPlayersClampPatch
+    internal class IncreaseMaxPlayersClampPatch
     {
-        static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
+        internal static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
         {
             var codes = instructions.ToList();
             for (int i = 0; i < codes.Count; i++)
             {
                 if (codes[i].opcode == OpCodes.Ldc_R4 && codes[i].OperandIs(5))
                 {
-                    codes[i] = new CodeInstruction(OpCodes.Ldc_R4, 20f);
+                    codes[i] = new CodeInstruction(OpCodes.Ldc_R4, (float)Plugin.Config.MaxPlayers);
                 }
             }
             return codes.AsEnumerable();
         }
     }
 
     [HarmonyPatch(typeof(CreateServerFormController), "Setup", MethodType.Normal)]
-    class IncreaseMaxPlayersPatch
+    internal class IncreaseMaxPlayersPatch
     {
-        static void Prefix(CreateServerFormController __instance)
+        internal static void Prefix(CreateServerFormController __instance)
         {
+            int maxPlayers = MPState.CurrentMasterServer.isOfficial ? 5 : Plugin.Config.MaxPlayers;
+            float[] playerValues = Enumerable.Range(2, maxPlayers-1).Select(x => (float)x).ToArray();
             FormattedFloatListSettingsController serverForm = __instance.GetField<FormattedFloatListSettingsController, CreateServerFormController>("_maxPlayersList");
-            serverForm.values = new float[] { 2f, 3f, 4f, 5f, 6f, 7f, 8f, 9f, 10f, 11f, 12f, 13f, 14f, 15f, 16f, 17f, 18f, 19f, 20f };
+            serverForm.values = playerValues;
         }
     }
 }

MultiplayerExtensions/HarmonyPatches/NetworkingPatches.cs

@@ -1,4 +1,8 @@
 using HarmonyLib;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection.Emit;
+using UnityEngine;
 
 namespace MultiplayerExtensions.HarmonyPatches
 {
@@ -8,32 +12,83 @@ namespace MultiplayerExtensions.HarmonyPatches
 	[HarmonyPatch(typeof(NetworkConfigSO), "masterServerEndPoint", MethodType.Getter)]
 	internal class GetMasterServerEndPointPatch
 	{
-		[HarmonyAfter("mod.serverbrowser")]
+		[HarmonyAfter("mod.serverbrowser", "com.Python.BeatTogether")]
 		[HarmonyPriority(Priority.Last)]
 		internal static void Postfix(NetworkConfigSO __instance, ref MasterServerEndPoint __result)
 		{
-			if (__result != null)
-			{
-				MasterServerInfo info = new MasterServerInfo(__result);
-				if (MPState.CurrentMasterServer.Equals(info))
-					return;
-				MPState.CurrentMasterServer = info;
-				MPEvents.RaiseMasterServerChanged(__instance, info);
-			}
+			if (MPState.CurrentMasterServer.Equals(__result))
+				return;
+			MPState.CurrentMasterServer = new MasterServerInfo(__result.hostName, __result.port, __instance.masterServerStatusUrl);
+			MPEvents.RaiseMasterServerChanged(__instance, MPState.CurrentMasterServer);
 		}
 	}
 
+	/// <summary>
+	/// For retrieving the currently used Master Server Status URL.
+	/// </summary>
 	[HarmonyPatch(typeof(MultiplayerSettingsPanelController), "SetLobbyCode", MethodType.Normal)]
 	internal class SetLobbyCodePatch
-	{
-		[HarmonyAfter("mod.serverbrowser")]
+	{ 
+		[HarmonyAfter("mod.serverbrowser", "com.Python.BeatTogether")]
 		[HarmonyPriority(Priority.Last)]
-		public static void Postfix(MultiplayerSettingsPanelController __instance, string code)
+		internal static void Postfix(MultiplayerSettingsPanelController __instance, string code)
 		{
 			if (code == MPState.LastRoomCode)
 				return;
 			MPState.LastRoomCode = code;
 			MPEvents.RaiseRoomCodeChanged(__instance, code);
 		}
 	}
+
+	[HarmonyPatch(typeof(ConnectedPlayerManager), "FlushReliableQueue", MethodType.Normal)]
+	internal class UpdateReliableFrequencyPatch
+    {
+		private static float nextTime = 0f;
+		private static float frequency = 0.1f;
+
+		internal static bool Prefix()
+		{
+			if (Time.time > nextTime)
+			{
+				nextTime = Time.time + frequency;
+				return true;
+			}
+			return false;
+		}
+    }
+
+	[HarmonyPatch(typeof(ConnectedPlayerManager), "FlushUnreliableQueue", MethodType.Normal)]
+	internal class UpdateUnreliableFrequencyPatch
+	{
+		private static float nextTime = 0f;
+		private static float frequency = 0.1f;
+
+		internal static bool Prefix()
+		{
+			if (Time.time > nextTime)
+			{
+				nextTime = Time.time + frequency;
+				return true;
+			}
+			return false;
+		}
+	}
+
+	//Make this work with harmony manager
+	[HarmonyPatch(typeof(ConnectedPlayerManager), "SendUnreliable", MethodType.Normal)]
+	internal class RemoveByteLimitPatch
+    {
+		internal static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
+		{
+			var codes = instructions.ToList();
+			for (int i = 0; i < codes.Count; i++)
+			{
+				if (codes[i].opcode == OpCodes.Ble_S)
+				{
+					codes[i] = new CodeInstruction(OpCodes.Br_S, codes[i].operand);
+				}
+			}
+			return codes.AsEnumerable();
+		}
+	}
 }

MultiplayerExtensions/Installers/InterfaceInstaller.cs

@@ -11,7 +11,7 @@ class InterfaceInstaller : MonoInstaller
         public override void InstallBindings()
         {
             Container.BindInterfacesAndSelfTo<LobbyPlaceManager>().AsSingle();
-            Container.BindInterfacesAndSelfTo<PlayerColorManager>().AsSingle();
+            Container.BindInterfacesAndSelfTo<LobbyEnvironmentManager>().AsSingle();
         }
 
         public override void Start()

MultiplayerExtensions/Installers/MultiplayerInstaller.cs

@@ -10,13 +10,14 @@ class MultiplayerInstaller : MonoInstaller
 		public HarmonyPatchInfo? lobbyPlayerDataPatch;
 		public HarmonyPatchInfo? levelLoaderPatch;
 
-		public override void InstallBindings()
-		{
-			Plugin.Log?.Info("Injecting Dependencies");
-			Container.BindInterfacesAndSelfTo<PacketManager>().AsSingle();
-			Container.BindInterfacesAndSelfTo<SessionManager>().AsSingle();
-			Container.BindInterfacesAndSelfTo<ExtendedPlayerManager>().AsSingle();
-		}
+        public override void InstallBindings()
+        {
+            Plugin.Log?.Info("Injecting Dependencies");
+            Container.BindInterfacesAndSelfTo<PacketManager>().AsSingle();
+            Container.BindInterfacesAndSelfTo<SessionManager>().AsSingle();
+            Container.BindInterfacesAndSelfTo<ExtendedPlayerManager>().AsSingle();
+			var _ = Container.Resolve<NetworkConfigSO>().masterServerEndPoint;
+        }
 
 		public override void Start()
 		{

MultiplayerExtensions/MPEvents.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using MultiplayerExtensions.Utilities;
 
@@ -81,23 +81,14 @@ public struct MasterServerInfo : IEquatable<MasterServerInfo>, IEquatable<Master
     {
         public readonly string hostname;
         public readonly int port;
+        public readonly string statusURL;
         public readonly bool isOfficial => hostname.Contains("beatsaber.com");
 
-        public MasterServerInfo(string hostname, int port)
+        public MasterServerInfo(string hostname, int port, string statusURL)
         {
             this.hostname = hostname;
             this.port = port;
-        }
-        public MasterServerInfo(MasterServerEndPoint endPoint)
-        {
-            if (endPoint == null)
-            {
-                hostname = "localhost";
-                port = 2328;
-                return;
-            }
-            hostname = endPoint.hostName;
-            port = endPoint.port;
+            this.statusURL = statusURL;
         }
 
         public override string ToString()
@@ -114,6 +105,11 @@ public bool Equals(MasterServerEndPoint endPoint)
             return endPoint.hostName == hostname && endPoint.port == port;
         }
 
+        public bool Equals(string status)
+        {
+            return status == statusURL;
+        }
+
         public override bool Equals(object obj)
         {
             if (obj is MasterServerEndPoint endPoint)

MultiplayerExtensions/MPState.cs

@@ -2,7 +2,7 @@
 {
     public static class MPState
     {
-        private static MasterServerInfo _masterServerEndPoint = new MasterServerInfo("localhost", 2328);
+        private static MasterServerInfo _masterServerEndPoint = new MasterServerInfo("localhost", 2328, "");
         /// <summary>
         /// The current known Master Server.
         /// </summary>

MultiplayerExtensions/MultiplayerExtensions.csproj

@@ -4,7 +4,7 @@
     <OutputType>Library</OutputType>
     <AppDesignerFolder>Properties</AppDesignerFolder>
     <AssemblyName>MultiplayerExtensions</AssemblyName>
-    <AssemblyVersion>0.4.3</AssemblyVersion>
+    <AssemblyVersion>0.4.4</AssemblyVersion>
     <TargetFramework>net472</TargetFramework>
     <DebugSymbols>true</DebugSymbols>
     <DebugType>portable</DebugType>

MultiplayerExtensions/Plugin.cs

@@ -53,34 +53,15 @@ public Plugin(IPALogger logger, Config conf, Zenjector zenjector, PluginMetadata
         public void OnApplicationStart()
         {
             Plugin.Log?.Info($"MultiplayerExtensions: '{VersionInfo.Description}'");
+
+            if (Plugin.Config.MaxPlayers > 100)
+                Plugin.Config.MaxPlayers = 100;
+            if (Plugin.Config.MaxPlayers < 10)
+                Plugin.Config.MaxPlayers = 10;
+
             HarmonyManager.ApplyDefaultPatches();
             Task versionTask = CheckVersion();
             MPEvents_Test();
-
-            playerPlacementAnglePatch = HarmonyManager.GetPatch<PlayerPlacementAnglePatch>()!;
-            increaseMaxPlayersClampPatch = HarmonyManager.GetPatch<IncreaseMaxPlayersClampPatch>()!;
-            increaseMaxPlayersPatch = HarmonyManager.GetPatch<IncreaseMaxPlayersPatch>()!;
-            MPEvents.MasterServerChanged += MasterServerChanged;
-        }
-
-        private HarmonyPatchInfo playerPlacementAnglePatch;
-        private HarmonyPatchInfo increaseMaxPlayersClampPatch;
-        private HarmonyPatchInfo increaseMaxPlayersPatch;
-
-        private void MasterServerChanged(object sender, MasterServerInfo e)
-        {
-            if (!e.isOfficial)
-            {
-                playerPlacementAnglePatch.ApplyPatch();
-                increaseMaxPlayersClampPatch.ApplyPatch();
-                increaseMaxPlayersPatch.ApplyPatch();
-            }
-            else
-            {
-                playerPlacementAnglePatch.RemovePatch();
-                increaseMaxPlayersClampPatch.RemovePatch();
-                increaseMaxPlayersPatch.RemovePatch();
-            }
         }
 
         [Conditional("DEBUG")]
@@ -93,7 +74,6 @@ public void MPEvents_Test()
                 else
                     Log?.Warn($"Beatmap Cleared by '{e.UserId}|{e.UserType.ToString()}'");
             };
-
         }
 
         [OnExit]

MultiplayerExtensions/Utilities/Config.cs

@@ -8,5 +8,6 @@ public class PluginConfig
         public bool CustomSongs { get; set; } = true;
         public bool EnforceMods { get; set; } = true;
         public string Color { get; set; } = "#08C0FF";
+        public int MaxPlayers { get; set; } = 10;
     }
 }

MultiplayerExtensions/manifest.json

@@ -3,7 +3,7 @@
   "id": "MultiplayerExtensions",
   "name": "MultiplayerExtensions",
   "author": "Zingabopp and Goobwabber",
-  "version": "0.4.3",
+  "version": "0.4.4",
   "description": "Expands the functionality of Beat Saber Multiplayer.",
   "gameVersion": "1.13.2",
   "dependsOn": {