using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Unity.Netcode;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.6", FrameworkDisplayName = ".NET Framework 4.6")]
[assembly: AssemblyCompany("LateCompany")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+46390ac2a94630e08dc503fea727629b88b5f211")]
[assembly: AssemblyProduct("LateCompany")]
[assembly: AssemblyTitle("LateCompany")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.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 LateCompany
{
public static class PluginInfo
{
public const string GUID = "twig.latecompany";
public const string PrintName = "Late Company";
public const string Version = "1.0.13";
}
[BepInPlugin("twig.latecompany", "Late Company", "1.0.13")]
internal class Plugin : BaseUnityPlugin
{
private ConfigEntry<bool> configLateJoinOrbitOnly;
public static bool AllowJoiningWhileLanded = false;
public static bool LobbyJoinable = true;
public void Awake()
{
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Expected O, but got Unknown
configLateJoinOrbitOnly = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Allow joining while landed", false, "Allow players to join while the ship is landed. (Will probably break some things)");
AllowJoiningWhileLanded = configLateJoinOrbitOnly.Value;
Harmony val = new Harmony("twig.latecompany");
val.PatchAll(typeof(Plugin).Assembly);
((BaseUnityPlugin)this).Logger.Log((LogLevel)16, (object)"Late Company loaded!");
}
public static void SetLobbyJoinable(bool joinable)
{
LobbyJoinable = joinable;
GameNetworkManager.Instance.SetLobbyJoinable(joinable);
QuickMenuManager val = Object.FindObjectOfType<QuickMenuManager>();
if (Object.op_Implicit((Object)(object)val))
{
val.inviteFriendsTextAlpha.alpha = (joinable ? 1f : 0.2f);
}
}
}
}
namespace LateCompany.Patches
{
[HarmonyPatch(typeof(GameNetworkManager), "LeaveLobbyAtGameStart")]
[HarmonyWrapSafe]
internal static class LeaveLobbyAtGameStart_Patch
{
[HarmonyPrefix]
private static bool Prefix()
{
return false;
}
}
[HarmonyPatch(typeof(GameNetworkManager), "ConnectionApproval")]
[HarmonyWrapSafe]
internal static class ConnectionApproval_Patch
{
[HarmonyPostfix]
private static void Postfix(ref ConnectionApprovalRequest request, ref ConnectionApprovalResponse response)
{
if (request.ClientNetworkId != NetworkManager.Singleton.LocalClientId && Plugin.LobbyJoinable && response.Reason == "Game has already started!")
{
response.Reason = "";
response.Approved = true;
}
}
}
[HarmonyPatch(typeof(QuickMenuManager), "DisableInviteFriendsButton")]
internal static class DisableInviteFriendsButton_Patch
{
[HarmonyPrefix]
private static bool Prefix()
{
return false;
}
}
[HarmonyPatch(typeof(QuickMenuManager), "InviteFriendsButton")]
internal static class InviteFriendsButton_Patch
{
[HarmonyPrefix]
private static bool Prefix()
{
if (Plugin.LobbyJoinable && !GameNetworkManager.Instance.disableSteam)
{
GameNetworkManager.Instance.InviteFriendsUI();
}
return false;
}
}
internal class RpcEnum : NetworkBehaviour
{
public static int None => 0;
public static int Client => 2;
public static int Server => 1;
}
internal static class WeatherSync
{
public static bool DoOverride = false;
public static LevelWeatherType CurrentWeather = (LevelWeatherType)(-1);
}
[HarmonyPatch(typeof(RoundManager), "__rpc_handler_1193916134")]
[HarmonyWrapSafe]
internal static class __rpc_handler_1193916134_Patch
{
public static FieldInfo RPCExecStage = typeof(NetworkBehaviour).GetField("__rpc_exec_stage", BindingFlags.Instance | BindingFlags.NonPublic);
[HarmonyPrefix]
private static bool Prefix(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
{
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
//IL_0082: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = target.NetworkManager;
if ((Object)(object)networkManager != (Object)null && networkManager.IsListening && !networkManager.IsHost)
{
try
{
int num = default(int);
ByteUnpacker.ReadValueBitPacked(reader, ref num);
int num2 = default(int);
ByteUnpacker.ReadValueBitPacked(reader, ref num2);
if (((FastBufferReader)(ref reader)).Position < ((FastBufferReader)(ref reader)).Length)
{
int num3 = default(int);
ByteUnpacker.ReadValueBitPacked(reader, ref num3);
num3 -= 255;
if (num3 < 0)
{
throw new Exception("In case of emergency, break glass.");
}
WeatherSync.CurrentWeather = (LevelWeatherType)num3;
WeatherSync.DoOverride = true;
}
RPCExecStage.SetValue(target, RpcEnum.Client);
((RoundManager)((target is RoundManager) ? target : null)).GenerateNewLevelClientRpc(num, num2);
RPCExecStage.SetValue(target, RpcEnum.None);
return false;
}
catch
{
WeatherSync.DoOverride = false;
((FastBufferReader)(ref reader)).Seek(0);
return true;
}
}
return true;
}
}
[HarmonyPatch(typeof(RoundManager), "SetToCurrentLevelWeather")]
internal static class SetToCurrentLevelWeather_Patch
{
[HarmonyPrefix]
private static void Prefix()
{
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
if (WeatherSync.DoOverride)
{
RoundManager.Instance.currentLevel.currentWeather = WeatherSync.CurrentWeather;
WeatherSync.DoOverride = false;
}
}
}
[HarmonyPatch(typeof(StartOfRound), "OnPlayerConnectedClientRpc")]
[HarmonyWrapSafe]
internal static class OnPlayerConnectedClientRpc_Patch
{
public static MethodInfo BeginSendClientRpc = typeof(RoundManager).GetMethod("__beginSendClientRpc", BindingFlags.Instance | BindingFlags.NonPublic);
public static MethodInfo EndSendClientRpc = typeof(RoundManager).GetMethod("__endSendClientRpc", BindingFlags.Instance | BindingFlags.NonPublic);
internal static void UpdateControlledState()
{
for (int i = 0; i < StartOfRound.Instance.connectedPlayersAmount + 1; i++)
{
if ((i == 0 || !((NetworkBehaviour)StartOfRound.Instance.allPlayerScripts[i]).IsOwnedByServer) && !StartOfRound.Instance.allPlayerScripts[i].isPlayerDead)
{
StartOfRound.Instance.allPlayerScripts[i].isPlayerControlled = true;
}
}
}
[HarmonyTranspiler]
private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
{
//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
//IL_00e6: Expected O, but got Unknown
List<CodeInstruction> list = new List<CodeInstruction>();
bool flag = false;
bool flag2 = false;
bool flag3 = false;
foreach (CodeInstruction instruction in instructions)
{
if (!flag3)
{
if (!flag && instruction.opcode == OpCodes.Call && instruction.operand != null && instruction.operand.ToString() == "System.Collections.IEnumerator setPlayerToSpawnPosition(UnityEngine.Transform, UnityEngine.Vector3)")
{
flag = true;
}
else
{
if (flag && instruction.opcode == OpCodes.Ldc_I4_0)
{
flag2 = true;
continue;
}
if (flag2 && instruction.opcode == OpCodes.Ldloc_0)
{
flag2 = false;
flag3 = true;
list.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(OnPlayerConnectedClientRpc_Patch), "UpdateControlledState", new Type[0], (Type[])null)));
}
}
}
if (!flag2)
{
list.Add(instruction);
}
}
if (!flag3)
{
Debug.LogError((object)"Failed to transpile StartOfRound::OnPlayerConnectedClientRpc");
}
return list.AsEnumerable();
}
[HarmonyPostfix]
private static void Postfix(StartOfRound __instance, ulong clientId, int connectedPlayers, ulong[] connectedPlayerIdsOrdered, int assignedPlayerObjectId, int serverMoneyAmount, int levelID, int profitQuota, int timeUntilDeadline, int quotaFulfilled, int randomSeed)
{
//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
//IL_00df: Unknown result type (might be due to invalid IL or missing references)
//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
//IL_0107: Unknown result type (might be due to invalid IL or missing references)
//IL_011d: Unknown result type (might be due to invalid IL or missing references)
//IL_0122: Unknown result type (might be due to invalid IL or missing references)
//IL_0124: Unknown result type (might be due to invalid IL or missing references)
//IL_0132: Unknown result type (might be due to invalid IL or missing references)
//IL_0140: Unknown result type (might be due to invalid IL or missing references)
//IL_0149: Unknown result type (might be due to invalid IL or missing references)
//IL_0153: Unknown result type (might be due to invalid IL or missing references)
//IL_0159: Expected I4, but got Unknown
//IL_0169: Unknown result type (might be due to invalid IL or missing references)
//IL_0180: Unknown result type (might be due to invalid IL or missing references)
//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
if (__instance.connectedPlayersAmount + 1 >= __instance.allPlayerScripts.Length)
{
Plugin.SetLobbyJoinable(joinable: false);
}
PlayerControllerB val = __instance.allPlayerScripts[assignedPlayerObjectId];
val.DisablePlayerModel(__instance.allPlayerObjects[assignedPlayerObjectId], true, true);
__instance.livingPlayers = __instance.connectedPlayersAmount + 1;
for (int i = 0; i < __instance.allPlayerScripts.Length; i++)
{
PlayerControllerB val2 = __instance.allPlayerScripts[i];
if (val2.isPlayerControlled && val2.isPlayerDead)
{
__instance.livingPlayers--;
}
}
if (((NetworkBehaviour)__instance).IsServer && !__instance.inShipPhase)
{
RoundManager instance = RoundManager.Instance;
ClientRpcParams val3 = default(ClientRpcParams);
val3.Send = new ClientRpcSendParams
{
TargetClientIds = new List<ulong> { clientId }
};
ClientRpcParams val4 = val3;
FastBufferWriter val5 = (FastBufferWriter)BeginSendClientRpc.Invoke(instance, new object[3] { 1193916134u, val4, 0 });
BytePacker.WriteValueBitPacked(val5, __instance.randomMapSeed);
BytePacker.WriteValueBitPacked(val5, __instance.currentLevelID);
BytePacker.WriteValueBitPacked(val5, instance.currentLevel.currentWeather + 255);
EndSendClientRpc.Invoke(instance, new object[4] { val5, 1193916134u, val4, 0 });
FastBufferWriter val6 = (FastBufferWriter)BeginSendClientRpc.Invoke(instance, new object[3] { 2729232387u, val4, 0 });
EndSendClientRpc.Invoke(instance, new object[4] { val6, 2729232387u, val4, 0 });
}
}
}
[HarmonyPatch(typeof(StartOfRound), "OnPlayerDC")]
[HarmonyWrapSafe]
internal static class OnPlayerDC_Patch
{
[HarmonyPostfix]
private static void Postfix()
{
if (StartOfRound.Instance.inShipPhase || (Plugin.AllowJoiningWhileLanded && StartOfRound.Instance.shipHasLanded))
{
Plugin.SetLobbyJoinable(joinable: true);
}
}
}
[HarmonyPatch(typeof(StartOfRound), "SetShipReadyToLand")]
internal static class SetShipReadyToLand_Patch
{
[HarmonyPostfix]
private static void Postfix()
{
if (StartOfRound.Instance.connectedPlayersAmount + 1 < StartOfRound.Instance.allPlayerScripts.Length)
{
Plugin.SetLobbyJoinable(joinable: true);
}
}
}
[HarmonyPatch(typeof(StartOfRound), "StartGame")]
internal static class StartGame_Patch
{
[HarmonyPrefix]
private static void Prefix()
{
Plugin.SetLobbyJoinable(joinable: false);
}
}
[HarmonyPatch(typeof(StartOfRound), "OnShipLandedMiscEvents")]
internal static class OnShipLandedMiscEvents_Patch
{
[HarmonyPostfix]
private static void Postfix()
{
if (Plugin.AllowJoiningWhileLanded && StartOfRound.Instance.connectedPlayersAmount + 1 < StartOfRound.Instance.allPlayerScripts.Length)
{
Plugin.SetLobbyJoinable(joinable: true);
}
}
}
[HarmonyPatch(typeof(StartOfRound), "ShipLeave")]
internal static class ShipLeave_Patch
{
[HarmonyPostfix]
private static void Postfix()
{
Plugin.SetLobbyJoinable(joinable: false);
}
}
}
