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.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.UI;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("SmallLobby")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("SmallLobby")]
[assembly: AssemblyCopyright("Copyright © 2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("48d2f6b1-c21c-43be-a1ba-3cdaba06d8ca")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace SmallLobby
{
public class Globals
{
public static int playerAmount = 4;
}
[BepInPlugin("ungodlyaura.SmallLobby", "Small Lobby", "1.0.2")]
public class LobbyMod : BaseUnityPlugin
{
private const string modGUID = "ungodlyaura.SmallLobby";
private const string modName = "Small Lobby";
private const string modVersion = "1.0.2";
private readonly Harmony harmony = new Harmony("ungodlyaura.SmallLobby");
private static LobbyMod Instance;
internal ManualLogSource mls;
private void Awake()
{
if ((Object)(object)Instance == (Object)null)
{
Instance = this;
}
mls = Logger.CreateLogSource("ungodlyaura.SmallLobby");
harmony.PatchAll();
}
}
}
namespace SmallLobby.Patches
{
public class TimeOfDayPatch
{
[HarmonyPatch(typeof(TimeOfDay), "Start")]
[HarmonyPostfix]
private static void TimeOfDayOnStartPost(TimeOfDay __instance)
{
__instance.globalTimeSpeedMultiplier = 1f - (float)(4 - Globals.playerAmount) * 0.1f;
}
}
[HarmonyPatch(typeof(RoundManager), "DespawnPropsAtEndOfRound")]
public class RoundManagerPatch
{
private static bool Prefix(RoundManager __instance)
{
GrabbableObject[] array = Object.FindObjectsOfType<GrabbableObject>();
for (int i = 0; i < array.Length; i++)
{
if ((!array[i].isHeld && !array[i].isInShipRoom) || (StartOfRound.Instance.allPlayersDead && Globals.playerAmount > 2 && array[i].itemProperties.isScrap))
{
if (array[i].isHeld && (Object)(object)array[i].playerHeldBy != (Object)null)
{
array[i].playerHeldBy.DropAllHeldItems(true, false);
}
((Component)array[i]).gameObject.GetComponent<NetworkObject>().Despawn(true);
}
else
{
array[i].scrapPersistedThroughRounds = true;
}
if (__instance.spawnedSyncedObjects.Contains(((Component)array[i]).gameObject))
{
__instance.spawnedSyncedObjects.Remove(((Component)array[i]).gameObject);
}
}
GameObject[] array2 = GameObject.FindGameObjectsWithTag("TemporaryEffect");
for (int j = 0; j < array2.Length; j++)
{
Object.Destroy((Object)(object)array2[j]);
}
return false;
}
}
[HarmonyPatch(typeof(HUDManager), "Update")]
[HarmonyPriority(100)]
public class HUDManagerPatch
{
private static int playerAmountCheck = 4;
private static bool Prefix(HUDManager __instance)
{
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
//IL_0098: Unknown result type (might be due to invalid IL or missing references)
//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
//IL_015a: Unknown result type (might be due to invalid IL or missing references)
//IL_0161: Unknown result type (might be due to invalid IL or missing references)
//IL_0179: Unknown result type (might be due to invalid IL or missing references)
//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
//IL_0203: Unknown result type (might be due to invalid IL or missing references)
//IL_020d: Unknown result type (might be due to invalid IL or missing references)
if (playerAmountCheck != Globals.playerAmount)
{
playerAmountCheck = Globals.playerAmount;
if (Globals.playerAmount == 0)
{
Globals.playerAmount = 1;
}
int num = 8 - Globals.playerAmount;
List<Image> list = new List<Image>(__instance.itemSlotIconFrames);
List<Image> list2 = new List<Image>(__instance.itemSlotIcons);
float num2 = Mathf.Abs(((Graphic)list[1]).rectTransform.anchoredPosition.x - ((Graphic)list[0]).rectTransform.anchoredPosition.x);
float y = ((Component)list[0]).GetComponent<RectTransform>().anchoredPosition.y;
Vector3 eulerAngles = ((Transform)((Graphic)list[0]).rectTransform).eulerAngles;
Vector3 eulerAngles2 = ((Transform)((Graphic)list2[0]).rectTransform).eulerAngles;
for (int i = 0; i < num; i++)
{
if (i >= list.Count)
{
list.Add(Object.Instantiate<Image>(list[i - 1], ((Component)list[0]).transform.parent));
list2.Add(((Component)((Component)list[i]).transform.GetChild(0)).GetComponent<Image>());
}
((Object)list[i]).name = $"Slot{i}";
((Graphic)list[i]).rectTransform.anchoredPosition = Vector2.up * y;
((Transform)((Graphic)list[i]).rectTransform).eulerAngles = eulerAngles;
((Object)list2[i]).name = "Icon";
((Transform)((Graphic)list2[i]).rectTransform).eulerAngles = eulerAngles2;
}
float num3 = num2 * (float)(list.Count - 1);
float num4 = num3 / 2f;
for (int j = 0; j < list.Count; j++)
{
float num5 = (float)j * num2 - num4;
((Graphic)list[j]).rectTransform.anchoredPosition = new Vector2(num5, ((Graphic)list[j]).rectTransform.anchoredPosition.y);
}
__instance.itemSlotIconFrames = list.ToArray();
__instance.itemSlotIcons = list2.ToArray();
}
return true;
}
}
[HarmonyPatch(typeof(StartOfRound), "Update")]
[HarmonyPriority(100)]
public class StartOfRoundPatch
{
private static bool Prefix(StartOfRound __instance)
{
__instance.maxShipItemCapacity = 1000;
if (Globals.playerAmount != __instance.ClientPlayerList.Count)
{
Globals.playerAmount = __instance.ClientPlayerList.Count;
}
return true;
}
}
[HarmonyPatch]
internal static class HotbarSlotSync
{
private static PlayerControllerB localPlayerController;
[HarmonyPatch(typeof(PlayerControllerB), "ConnectClientToPlayerObject")]
[HarmonyPostfix]
public static void Init(PlayerControllerB __instance)
{
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Expected O, but got Unknown
localPlayerController = __instance;
if (NetworkManager.Singleton.IsServer)
{
NetworkManager.Singleton.CustomMessagingManager.RegisterNamedMessageHandler("HotbarSlotChange", new HandleNamedMessageDelegate(OnReceiveHotbarSlotChange));
}
}
public static void SendHotbarSlotChange(int hotbarSlot)
{
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
if (NetworkManager.Singleton.IsClient)
{
FastBufferWriter val = default(FastBufferWriter);
((FastBufferWriter)(ref val))..ctor(4, (Allocator)2, -1);
try
{
((FastBufferWriter)(ref val)).WriteValue<int>(ref hotbarSlot, default(ForPrimitives));
NetworkManager.Singleton.CustomMessagingManager.SendNamedMessage("HotbarSlotChange", 0uL, val, (NetworkDelivery)3);
}
finally
{
((IDisposable)(FastBufferWriter)(ref val)).Dispose();
}
}
}
private static void OnReceiveHotbarSlotChange(ulong clientId, FastBufferReader reader)
{
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
if (clientId != localPlayerController.playerClientId && ((FastBufferReader)(ref reader)).TryBeginRead(4))
{
int hotbarSlot = default(int);
((FastBufferReader)(ref reader)).ReadValue<int>(ref hotbarSlot, default(ForPrimitives));
UpdateClientHotbarSlot(clientId, hotbarSlot);
}
}
private static void UpdateClientHotbarSlot(ulong clientId, int hotbarSlot)
{
for (int i = 0; i < StartOfRound.Instance.allPlayerScripts.Length; i++)
{
if (StartOfRound.Instance.allPlayerScripts[i].playerClientId == clientId)
{
CallSwitchToItemSlotMethod(StartOfRound.Instance.allPlayerScripts[i], hotbarSlot);
break;
}
}
}
public static void SwapHotbarSlot(int hotbarIndex)
{
SendHotbarSlotChange(hotbarIndex);
CallSwitchToItemSlotMethod(localPlayerController, hotbarIndex);
}
private static void CallSwitchToItemSlotMethod(PlayerControllerB player, int hotbarIndex)
{
MethodInfo method = ((object)player).GetType().GetMethod("SwitchToItemSlot", BindingFlags.Instance | BindingFlags.NonPublic);
method.Invoke(player, new object[2] { hotbarIndex, null });
}
}
[HarmonyPatch]
internal class Keybinds
{
private static InputAction[] quickItemShortcutActions;
private static PlayerControllerB localPlayerController;
[HarmonyPatch(typeof(PlayerControllerB), "Awake")]
[HarmonyPostfix]
public static void Setup(PlayerControllerB __instance)
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: 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_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_004c: Unknown result type (might be due to invalid IL or missing references)
//IL_005c: Unknown result type (might be due to invalid IL or missing references)
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_006f: 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)
//IL_0087: Unknown result type (might be due to invalid IL or missing references)
//IL_0097: Unknown result type (might be due to invalid IL or missing references)
//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
//IL_00e3: Expected O, but got Unknown
localPlayerController = __instance;
MovementActions movement = localPlayerController.playerActions.Movement;
BindingSyntax val = InputActionSetupExtensions.ChangeBinding(((MovementActions)(ref movement)).Emote1, 0);
((BindingSyntax)(ref val)).Erase();
movement = localPlayerController.playerActions.Movement;
InputActionSetupExtensions.AddBinding(((MovementActions)(ref movement)).Emote1, "<Keyboard>/F1", (string)null, (string)null, (string)null);
movement = localPlayerController.playerActions.Movement;
val = InputActionSetupExtensions.ChangeBinding(((MovementActions)(ref movement)).Emote2, 0);
((BindingSyntax)(ref val)).Erase();
movement = localPlayerController.playerActions.Movement;
InputActionSetupExtensions.AddBinding(((MovementActions)(ref movement)).Emote2, "<Keyboard>/F2", (string)null, (string)null, (string)null);
quickItemShortcutActions = (InputAction[])(object)new InputAction[__instance.ItemSlots.Length + 8 - Globals.playerAmount];
for (int i = 0; i < quickItemShortcutActions.Length; i++)
{
quickItemShortcutActions[i] = new InputAction((string)null, (InputActionType)0, $"<Keyboard>/{i + 1}", "Press", (string)null, (string)null);
}
if (((Component)localPlayerController).gameObject.activeSelf)
{
for (int j = 0; j < quickItemShortcutActions.Length; j++)
{
quickItemShortcutActions[j].Enable();
quickItemShortcutActions[j].performed += OnPressItemSlotHotkeyAction;
}
}
}
private static void SubscribeToEvents()
{
for (int i = 0; i < quickItemShortcutActions.Length; i++)
{
quickItemShortcutActions[i].Enable();
quickItemShortcutActions[i].performed += OnPressItemSlotHotkeyAction;
}
}
[HarmonyPatch(typeof(PlayerControllerB), "OnEnable")]
[HarmonyPostfix]
public static void OnEnable(PlayerControllerB __instance)
{
if ((Object)(object)__instance == (Object)(object)localPlayerController)
{
SubscribeToEvents();
}
}
[HarmonyPatch(typeof(PlayerControllerB), "OnDisable")]
[HarmonyPostfix]
public static void OnDisable(PlayerControllerB __instance)
{
for (int i = 0; i < quickItemShortcutActions.Length; i++)
{
quickItemShortcutActions[i].performed -= OnPressItemSlotHotkeyAction;
quickItemShortcutActions[i].Disable();
}
}
private static void OnPressItemSlotHotkeyAction(CallbackContext context)
{
if (!((Object)(object)localPlayerController == (Object)null) && ((NetworkBehaviour)localPlayerController).IsOwner && localPlayerController.isPlayerControlled && !localPlayerController.inTerminalMenu && (!((NetworkBehaviour)localPlayerController).IsServer || localPlayerController.isHostPlayerObject) && ((CallbackContext)(ref context)).performed)
{
string name = ((CallbackContext)(ref context)).control.name;
if (int.TryParse(name, out var result))
{
result--;
HotbarSlotSync.SwapHotbarSlot(result);
}
}
}
}
[HarmonyPatch(typeof(PlayerControllerB), "Update")]
internal class PlayerControllerBPatch
{
[HarmonyPatch(typeof(PlayerControllerB), "SwitchItem_performed")]
[HarmonyTranspiler]
private static IEnumerable<CodeInstruction> PatchSwitchItemInterval(IEnumerable<CodeInstruction> instructions)
{
List<CodeInstruction> list = new List<CodeInstruction>(instructions);
for (int i = 0; i < list.Count; i++)
{
if (list[i].opcode == OpCodes.Ldc_R4 && (float)list[i].operand == 0.3f)
{
list[i].operand = 0.01f;
break;
}
}
return list.AsEnumerable();
}
[HarmonyPatch("Update")]
[HarmonyPostfix]
private static void ItemsPatch(ref float ___carryWeight, ref bool ___twoHanded, PlayerControllerB __instance)
{
if (__instance.ItemSlots.Length != 8 - Globals.playerAmount)
{
__instance.DropAllHeldItems(true, false);
__instance.ItemSlots = (GrabbableObject[])(object)new GrabbableObject[8 - Globals.playerAmount];
}
float num = 1f;
if (__instance.ItemSlots != null)
{
GrabbableObject[] itemSlots = __instance.ItemSlots;
foreach (GrabbableObject val in itemSlots)
{
if ((Object)(object)val != (Object)null)
{
num += Mathf.Clamp(val.itemProperties.weight - 1f, 0f, 10f);
}
}
}
num -= 1f;
num *= 1f * (0.25f * (float)Globals.playerAmount);
if (Globals.playerAmount < 4)
{
___twoHanded = false;
}
num += 1f;
___carryWeight = num;
}
}
}
