using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using BlindBirdStringEnjoyersImprovements.Patches;
using GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.UI;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: IgnoresAccessChecksTo("UnityEngine")]
[assembly: AssemblyCompany("BlindBirdStringEnjoyersImprovements")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("General game improvements")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+3aabb7677e961e81040ef9a5948193713cbf73d5")]
[assembly: AssemblyProduct("BlindBirdStringEnjoyersImprovements")]
[assembly: AssemblyTitle("BlindBirdStringEnjoyersImprovements")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[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 BlindBirdStringEnjoyersImprovements
{
[BepInPlugin("BlindBirdStringEnjoyersImprovements", "BlindBirdStringEnjoyersImprovements", "1.0.0")]
public class Plugin : BaseUnityPlugin
{
private readonly Harmony harmony = new Harmony("BlindBirdStringEnjoyersImprovements");
public static ManualLogSource LogSource;
private void Awake()
{
((BaseUnityPlugin)this).Logger.LogInfo((object)"Plugin BlindBirdStringEnjoyersImprovements is loaded!");
LogSource = Logger.CreateLogSource("BlindBirdStringEnjoyersImprovements");
harmony.PatchAll(typeof(EntranceTeleportPatch));
harmony.PatchAll(typeof(GrabbableObjectPatch));
harmony.PatchAll(typeof(StormyWeatherPatch));
harmony.PatchAll(typeof(HUDManagerPatch));
harmony.PatchAll(typeof(PreInitSceneScriptPatch));
LogSource.LogInfo((object)"Patched!");
}
}
public static class Utils
{
public static void CreateScanNodeOnObject(GameObject obj, int nodeType, int minRange, int maxRange, string headerText)
{
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
GameObject val = new GameObject("ScanNode", new Type[2]
{
typeof(ScanNodeProperties),
typeof(BoxCollider)
})
{
layer = LayerMask.NameToLayer("ScanNode")
};
val.transform.parent = obj.transform;
val.transform.SetLocalPositionAndRotation(Vector3.zero, Quaternion.identity);
ScanNodeProperties component = val.GetComponent<ScanNodeProperties>();
component.nodeType = nodeType;
component.minRange = minRange;
component.maxRange = maxRange;
component.headerText = headerText;
}
}
public static class PluginInfo
{
public const string PLUGIN_GUID = "BlindBirdStringEnjoyersImprovements";
public const string PLUGIN_NAME = "BlindBirdStringEnjoyersImprovements";
public const string PLUGIN_VERSION = "1.0.0";
}
}
namespace BlindBirdStringEnjoyersImprovements.Patches
{
public static class EntranceTeleportPatch
{
[HarmonyPatch(typeof(EntranceTeleport), "TeleportPlayer")]
[HarmonyPostfix]
private static void TeleportPlayer(EntranceTeleport __instance)
{
if (__instance.entranceId != 0 && __instance.isEntranceToBuilding)
{
FlipPlayer(__instance, GameNetworkManager.Instance.localPlayerController);
}
}
[HarmonyPatch(typeof(EntranceTeleport), "TeleportPlayerClientRpc")]
[HarmonyPostfix]
private static void TeleportPlayerClientRpc(EntranceTeleport __instance, int playerObj)
{
if (__instance.entranceId != 0 && __instance.isEntranceToBuilding)
{
PlayerControllerB val = __instance.playersManager.allPlayerScripts[playerObj];
if (!((NetworkBehaviour)val).IsOwner)
{
FlipPlayer(__instance, val);
}
}
}
private static void FlipPlayer(EntranceTeleport instance, PlayerControllerB player)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: 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_002a: Unknown result type (might be due to invalid IL or missing references)
Vector3 eulerAngles = instance.exitPoint.eulerAngles;
((Component)player).transform.rotation = Quaternion.Euler(eulerAngles.x, eulerAngles.y + 180f, eulerAngles.z);
}
}
public class GrabbableObjectPatch
{
private static HashSet<GrabbableObject> _itemsToKeepInPlace = new HashSet<GrabbableObject>();
[HarmonyPatch(typeof(GrabbableObject), "Start")]
[HarmonyPrefix]
private static void Start_Pre(GrabbableObject __instance)
{
List<Type> obj = new List<Type>
{
typeof(BoomboxItem),
typeof(ExtensionLadderItem),
typeof(FlashlightItem),
typeof(JetpackItem),
typeof(LockPicker),
typeof(RadarBoosterItem),
typeof(Shovel),
typeof(SprayPaintItem),
typeof(StunGrenadeItem),
typeof(TetraChemicalItem),
typeof(WalkieTalkie),
typeof(PatcherTool),
typeof(BeltBagItem)
};
if (!__instance.itemProperties.isScrap)
{
ScanNodeProperties componentInChildren = ((Component)__instance).GetComponentInChildren<ScanNodeProperties>();
if (componentInChildren != null)
{
string subText = componentInChildren.subText;
__instance.SetScrapValue(0);
if (subText != null && !subText.ToLower().StartsWith("value"))
{
componentInChildren.subText = subText;
}
}
else
{
__instance.scrapValue = 0;
}
}
if (obj.Contains(((object)__instance).GetType()) && (Object)(object)((Component)__instance).GetComponentInChildren<ScanNodeProperties>() == (Object)null)
{
Utils.CreateScanNodeOnObject(((Component)__instance).gameObject, 0, 1, 13, __instance.itemProperties.itemName);
}
}
}
public static class HUDManagerPatch
{
[HarmonyPatch(typeof(HUDManager), "Update")]
[HarmonyPostfix]
private static void Update(HUDManager __instance)
{
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_0117: Unknown result type (might be due to invalid IL or missing references)
//IL_0103: Unknown result type (might be due to invalid IL or missing references)
//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
for (int i = 0; i < __instance.itemSlotIcons.Length; i++)
{
StartOfRound instance = StartOfRound.Instance;
GrabbableObject val = ((instance != null) ? instance.localPlayerController.ItemSlots[i] : null);
if ((Object)(object)val == (Object)null || (Object)(object)StormyWeatherPatch.Instance == (Object)null)
{
((Graphic)__instance.itemSlotIcons[i]).color = Color.white;
continue;
}
Traverse obj = Traverse.Create((object)StormyWeatherPatch.Instance);
GameObject val2 = ((obj != null) ? obj.Field("setStaticToObject").GetValue<GameObject>() : null);
GrabbableObject val3 = null;
try
{
if ((Object)(object)val2 != (Object)null)
{
val3 = val2.GetComponent<GrabbableObject>();
}
}
catch
{
}
StartOfRound instance2 = StartOfRound.Instance;
if (instance2 != null && !instance2.localPlayerController.isInsideFactory)
{
StartOfRound instance3 = StartOfRound.Instance;
if (instance3 != null && !instance3.localPlayerController.isInElevator && (Object)(object)val3 != (Object)null && (Object)(object)val3 == (Object)(object)val)
{
((Graphic)__instance.itemSlotIcons[i]).color = Color.red;
continue;
}
}
if ((Object)(object)StormyWeatherPatch.Instance != (Object)null && val.itemProperties.isConductiveMetal)
{
((Graphic)__instance.itemSlotIcons[i]).color = Color.yellow;
}
else
{
((Graphic)__instance.itemSlotIcons[i]).color = Color.white;
}
}
}
}
public static class PreInitSceneScriptPatch
{
[HarmonyPatch(typeof(PreInitSceneScript), "SkipToFinalSetting")]
[HarmonyPrefix]
private static bool SkipToFinalSetting(PreInitSceneScript __instance)
{
__instance.ChooseLaunchOption(true);
return false;
}
}
public static class StormyWeatherPatch
{
public static StormyWeather Instance { get; private set; }
[HarmonyPatch(typeof(StormyWeather), "OnEnable")]
[HarmonyPostfix]
private static void OnEnable(StormyWeather __instance)
{
if ((Object)(object)Instance != (Object)(object)__instance)
{
Instance = __instance;
}
}
[HarmonyPatch(typeof(StormyWeather), "OnDisable")]
[HarmonyPostfix]
private static void OnDisable()
{
Instance = null;
}
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}