using System;
using System.Collections;
using System.Diagnostics;
using System.Globalization;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.IL2CPP;
using BepInEx.IL2CPP.Utils;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using ModList;
using SteamworksNative;
using TMPro;
using UnhollowerBaseLib;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace FloatingPlayerPatch
{
internal static class ModListCompatibility
{
internal const string GUID = "lammas123.ModList";
internal static bool? enabled;
internal static bool Enabled
{
get
{
if (enabled.HasValue)
{
return enabled.Value;
}
bool? flag = (enabled = ((BaseChainloader<BasePlugin>)(object)IL2CPPChainloader.Instance).Plugins.ContainsKey("lammas123.ModList"));
return flag.Value;
}
}
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
internal static void AddMod(string guid, bool required = false)
{
Api.AddMod(guid, required);
}
}
internal static class Patches
{
internal static float hostConnectionStartTime;
[HarmonyPatch(typeof(MonoBehaviourPublicGataInefObInUnique), "Method_Private_Void_GameObject_Boolean_Vector3_Quaternion_0")]
[HarmonyPatch(typeof(MonoBehaviourPublicCSDi2UIInstObUIloDiUnique), "Method_Private_Void_0")]
[HarmonyPrefix]
internal static bool PreBepinexDetection()
{
return false;
}
[HarmonyPatch(typeof(MonoBehaviourPublicPlVoUI9GaVoUI9UsPlUnique), "PlayerPosition")]
[HarmonyPrefix]
[HarmonyPriority(200)]
internal static bool PreServerHandlePlayerPosition(ulong param_0, ObjectPublicIDisposableLi1ByInByBoUnique param_1)
{
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
//IL_0060: Unknown result type (might be due to invalid IL or missing references)
if (MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.IsLobbyOwner())
{
MonoBehaviourPublicInInUnique.PlayerPosition(param_0, new Vector3(BitConverter.ToSingle(Il2CppArrayBase<byte>.op_Implicit((Il2CppArrayBase<byte>)(object)param_1.field_Private_ArrayOf_Byte_0), 8), BitConverter.ToSingle(Il2CppArrayBase<byte>.op_Implicit((Il2CppArrayBase<byte>)(object)param_1.field_Private_ArrayOf_Byte_0), 12), BitConverter.ToSingle(Il2CppArrayBase<byte>.op_Implicit((Il2CppArrayBase<byte>)(object)param_1.field_Private_ArrayOf_Byte_0), 16)));
return true;
}
if (FloatingPlayerPatch.Instance.lobbyHasFloatingPlayerPatch)
{
return param_0 == MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.field_Private_CSteamID_1.m_SteamID;
}
return true;
}
[HarmonyPatch(typeof(MonoBehaviourPublicPlVoUI9GaVoUI9UsPlUnique), "PlayerRotation")]
[HarmonyPrefix]
[HarmonyPriority(200)]
internal static bool PreServerHandlePlayerRotation(ulong param_0, ObjectPublicIDisposableLi1ByInByBoUnique param_1)
{
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
if (MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.IsLobbyOwner())
{
MonoBehaviourPublicInInUnique.PlayerRotation(param_0, BitConverter.ToSingle(Il2CppArrayBase<byte>.op_Implicit((Il2CppArrayBase<byte>)(object)param_1.field_Private_ArrayOf_Byte_0), 8), BitConverter.ToSingle(Il2CppArrayBase<byte>.op_Implicit((Il2CppArrayBase<byte>)(object)param_1.field_Private_ArrayOf_Byte_0), 12));
return true;
}
if (FloatingPlayerPatch.Instance.lobbyHasFloatingPlayerPatch)
{
return param_0 == MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.field_Private_CSteamID_1.m_SteamID;
}
return true;
}
[HarmonyPatch(typeof(MonoBehaviourPublicTrrocaTrInSiVeSipoObUnique), "Method_Private_Void_Vector3_EnumNPublicSealedvaClMeFaAn5vUnique_0")]
[HarmonyPrefix]
internal static void PrePlayerCommunicationUpdatePosition(MonoBehaviourPublicTrrocaTrInSiVeSipoObUnique __instance)
{
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
if (!MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.IsLobbyOwner() && FloatingPlayerPatch.Instance.lobbyHasFloatingPlayerPatch)
{
__instance.idToDistance[MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.field_Private_CSteamID_1.m_SteamID] = (EnumNPublicSealedvaClMeFaAn5vUnique)0;
}
}
[HarmonyPatch(typeof(MonoBehaviourPublicTrrocaTrInSiVeSipoObUnique), "Method_Private_Void_Single_Single_EnumNPublicSealedvaClMeFaAn5vUnique_0")]
[HarmonyPrefix]
internal static void PrePlayerCommunicationUpdateRotation(MonoBehaviourPublicTrrocaTrInSiVeSipoObUnique __instance)
{
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
if (!MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.IsLobbyOwner() && FloatingPlayerPatch.Instance.lobbyHasFloatingPlayerPatch)
{
__instance.idToDistance[MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.field_Private_CSteamID_1.m_SteamID] = (EnumNPublicSealedvaClMeFaAn5vUnique)0;
}
}
[HarmonyPatch(typeof(MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique), "OnEnable")]
[HarmonyPrefix]
internal static bool PreSteamManagerOnEnable(MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique __instance)
{
if ((Object)(object)__instance == (Object)(object)MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance)
{
MonoBehaviourExtensions.StartCoroutine((MonoBehaviour)(object)MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance, CoroCheckHostConnection());
MonoBehaviourExtensions.StartCoroutine((MonoBehaviour)(object)MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance, CoroTryEstablishHostConnection());
MonoBehaviourExtensions.StartCoroutine((MonoBehaviour)(object)MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance, CoroTryEstablishConnections());
}
return false;
}
internal unsafe static IEnumerator CoroCheckHostConnection()
{
while (true)
{
yield return (object)new WaitForSeconds(0.1f);
if (MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.currentLobby.m_SteamID != 0L && MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.field_Private_CSteamID_1.m_SteamID != 0L && FloatingPlayerPatch.Instance.establishingHostConnection && Object.op_Implicit((Object)(object)MonoBehaviourPublicGalomeGacrsemiGaupObUnique.Instance))
{
ESteamNetworkingConnectionState state = SessionInfo.GetState(MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.field_Private_CSteamID_1.m_SteamID);
string text = "k_ESteamNetworkingConnectionState_";
string text2 = ((object)(*(ESteamNetworkingConnectionState*)(&state))/*cast due to .constrained prefix*/).ToString();
if (text2.StartsWith(text))
{
string text3 = text2;
int length = text.Length;
text2 = text3.Substring(length, text3.Length - length);
}
try
{
((TMP_Text)((Component)MonoBehaviourPublicGalomeGacrsemiGaupObUnique.Instance.lobbyUi.transform.GetChild(1).GetChild(0).GetChild(0)
.GetChild(0)).GetComponent<TextMeshProUGUI>()).text = $"Joining server, please wait...<size=75%>\nHost Connection State: {text2}\nElapsed: {Time.realtimeSinceStartup - hostConnectionStartTime:0.0}s";
}
catch
{
}
}
}
}
internal static IEnumerator CoroTryEstablishHostConnection()
{
while (true)
{
yield return (object)new WaitForSeconds(3f);
if (MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.currentLobby.m_SteamID != 0L && MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.field_Private_CSteamID_1.m_SteamID != 0L && FloatingPlayerPatch.Instance.establishingHostConnection)
{
MonoBehaviourPublicInpabyInInInUnique.LoadMapRequest();
ESteamNetworkingConnectionState state = SessionInfo.GetState(MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.field_Private_CSteamID_1.m_SteamID);
if ((int)state != 3 && (int)state != 1 && (int)state != 2)
{
MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.StopP2P(MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.field_Private_CSteamID_1);
MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.NewAcceptP2P(MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.field_Private_CSteamID_1);
MonoBehaviourPublicInpabyInInInUnique.HandShake(MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.field_Private_CSteamID_1.m_SteamID);
}
}
}
}
internal static IEnumerator CoroTryEstablishConnections()
{
while (true)
{
yield return (object)new WaitForSeconds(10f);
if (MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.currentLobby.m_SteamID != 0L && MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.field_Private_CSteamID_1.m_SteamID != 0L && !FloatingPlayerPatch.Instance.establishingHostConnection)
{
MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.Method_Private_Void_PDM_1();
}
}
}
[HarmonyPatch(typeof(MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique), "Method_Private_Void_LobbyEnter_t_PDM_1")]
[HarmonyPrefix]
internal static void PreSteamManagerLobbyEnter(LobbyEnter_t param_1)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
CSteamID val = default(CSteamID);
((CSteamID)(ref val))..ctor(param_1.m_ulSteamIDLobby);
if (SteamMatchmaking.GetLobbyOwner(val).m_SteamID == MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.field_Private_CSteamID_0.m_SteamID)
{
SteamMatchmaking.SetLobbyData(val, "lammas123.FloatingPlayerPatch", "1.4.0");
FloatingPlayerPatch.Instance.establishingHostConnection = false;
hostConnectionStartTime = 0f;
return;
}
FloatingPlayerPatch.Instance.lobbyHasFloatingPlayerPatch = !string.IsNullOrEmpty(SteamMatchmaking.GetLobbyData(val, "lammas123.FloatingPlayerPatch"));
FloatingPlayerPatch.Instance.establishingHostConnection = true;
if (hostConnectionStartTime == 0f)
{
hostConnectionStartTime = Time.realtimeSinceStartup;
}
}
[HarmonyPatch(typeof(MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique), "JoinLobby")]
[HarmonyPrefix]
internal static void PreSteamManagerJoinLobby(CSteamID param_1)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
if (param_1 != MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.currentLobby)
{
FloatingPlayerPatch.Instance.establishingHostConnection = true;
hostConnectionStartTime = Time.realtimeSinceStartup;
}
}
[HarmonyPatch(typeof(MonoBehaviourPublicUIInUIByUIUnique), "LoadMap")]
[HarmonyPostfix]
internal static void PostClientHandleLoadMap()
{
FloatingPlayerPatch.Instance.establishingHostConnection = false;
hostConnectionStartTime = 0f;
}
[HarmonyPatch(typeof(MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique), "LeaveLobby")]
[HarmonyPostfix]
internal static void PostSteamManagerLeaveLobby()
{
FloatingPlayerPatch.Instance.lobbyHasFloatingPlayerPatch = false;
FloatingPlayerPatch.Instance.establishingHostConnection = false;
hostConnectionStartTime = 0f;
}
internal static bool ShouldConnect(ulong clientId)
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
if (MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.currentLobby.m_SteamID == 0L)
{
return false;
}
if (clientId <= 1)
{
return false;
}
if (MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.IsLobbyOwner() || clientId == MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.field_Private_CSteamID_1.m_SteamID)
{
return true;
}
if (!FloatingPlayerPatch.Instance.establishingHostConnection)
{
return !FloatingPlayerPatch.Instance.lobbyHasFloatingPlayerPatch;
}
return false;
}
[HarmonyPatch(typeof(MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique), "NewAcceptP2P", new Type[] { typeof(CSteamID) })]
[HarmonyPrefix]
internal static bool PreSteamManagerNewAcceptP2P(CSteamID param_1)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
return ShouldConnect(param_1.m_SteamID);
}
[HarmonyPatch(typeof(MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique), "NewAcceptP2P", new Type[] { typeof(SteamNetworkingIdentity) })]
[HarmonyPrefix]
internal static bool PreSteamManagerNewAcceptP2P(SteamNetworkingIdentity param_1)
{
return ShouldConnect(param_1.GetSteamID64());
}
[HarmonyPatch(typeof(MonoBehaviourPublicInStInpabyDiInpaby2Unique), "SendPacket")]
[HarmonyPrefix]
internal static bool PreSteamPacketManagerSendPacket(CSteamID param_0)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
return ShouldConnect(param_0.m_SteamID);
}
[HarmonyPatch(typeof(MonoBehaviour1PublicIn_cObIn_cObInInUnique), "Method_Internal_Boolean_CSteamID_ArraySegment_1_Byte_EP2PSend_Boolean_1")]
[HarmonyPrefix]
internal static bool Pre_Dissonance_Integrations_SteamworksP2P__SteamworksP2PCommsNetworkSend(CSteamID param_1)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
return ShouldConnect(param_1.m_SteamID);
}
}
[BepInPlugin("lammas123.FloatingPlayerPatch", "FloatingPlayerPatch", "1.4.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public sealed class FloatingPlayerPatch : BasePlugin
{
internal bool lobbyHasFloatingPlayerPatch;
internal bool establishingHostConnection;
internal static FloatingPlayerPatch Instance { get; private set; }
public override void Load()
{
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: Expected O, but got Unknown
CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;
CultureInfo.CurrentUICulture = CultureInfo.InvariantCulture;
CultureInfo.DefaultThreadCurrentCulture = CultureInfo.InvariantCulture;
CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.InvariantCulture;
Instance = this;
if (ModListCompatibility.Enabled)
{
ModListCompatibility.AddMod("lammas123.FloatingPlayerPatch");
}
new Harmony("FloatingPlayerPatch").PatchAll(typeof(Patches));
ManualLogSource log = ((BasePlugin)this).Log;
bool flag = default(bool);
BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(15, 2, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Initialized [");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("FloatingPlayerPatch");
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("1.4.0");
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("]");
}
log.LogInfo(val);
}
}
internal static class SessionInfo
{
private static readonly SteamNetworkingIdentity _identity = new SteamNetworkingIdentity();
private static readonly SteamNetConnectionInfo_t _info = new SteamNetConnectionInfo_t();
private static readonly SteamNetworkingQuickConnectionStatus _status = new SteamNetworkingQuickConnectionStatus();
internal unsafe static ESteamNetworkingConnectionState GetState(ulong steamId)
{
_identity.SetSteamID64(steamId);
IntPtr* ptr = stackalloc IntPtr[3];
*ptr = IL2CPP.il2cpp_object_unbox(((Il2CppObjectBase)_identity).Pointer);
ptr[1] = IL2CPP.il2cpp_object_unbox(((Il2CppObjectBase)_info).Pointer);
ptr[2] = IL2CPP.il2cpp_object_unbox(((Il2CppObjectBase)_status).Pointer);
IntPtr zero = IntPtr.Zero;
IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(SteamNetworkingMessages.NativeMethodInfoPtr_GetSessionConnectionInfo_Public_Static_ESteamNetworkingConnectionState_byref_SteamNetworkingIdentity_byref_SteamNetConnectionInfo_t_byref_SteamNetworkingQuickConnectionStatus_0, IntPtr.Zero, (void**)ptr, ref zero);
Il2CppException.RaiseExceptionIfNecessary(zero);
return (ESteamNetworkingConnectionState)(*(int*)(void*)IL2CPP.il2cpp_object_unbox(intPtr));
}
}
public static class MyPluginInfo
{
public const string PLUGIN_GUID = "lammas123.FloatingPlayerPatch";
public const string PLUGIN_NAME = "FloatingPlayerPatch";
public const string PLUGIN_VERSION = "1.4.0";
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
