using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Reflection.Emit;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using BetterEmote.AssetScripts;
using BunkbedRevive;
using CSync.Extensions;
using CSync.Lib;
using CustomItemBehaviourLibrary.AbstractItems;
using Dawn.Internal;
using Dawn.Utils;
using Dissonance.Integrations.Unity_NFGO;
using DunGen;
using DunGen.Tags;
using FacilityMeltdown.API;
using GameNetcodeStuff;
using GeneralImprovements;
using HarmonyLib;
using LCPeeper;
using LethalBots.AI;
using LethalBots.AI.AIStates;
using LethalBots.Configs;
using LethalBots.Constants;
using LethalBots.Enums;
using LethalBots.Inputs;
using LethalBots.Managers;
using LethalBots.NetcodePatcher;
using LethalBots.NetworkSerializers;
using LethalBots.Patches.EnemiesPatches;
using LethalBots.Patches.GameEnginePatches;
using LethalBots.Patches.MapHazardsPatches;
using LethalBots.Patches.MapPatches;
using LethalBots.Patches.ModPatches.AdditionalNetworking;
using LethalBots.Patches.ModPatches.BetterEmotes;
using LethalBots.Patches.ModPatches.BunkbedRevive;
using LethalBots.Patches.ModPatches.DawnLib;
using LethalBots.Patches.ModPatches.LCVR;
using LethalBots.Patches.ModPatches.LethalPhones;
using LethalBots.Patches.ModPatches.LethalProgression;
using LethalBots.Patches.ModPatches.ModelRplcmntAPI;
using LethalBots.Patches.ModPatches.MoreEmotes;
using LethalBots.Patches.ModPatches.Peepers;
using LethalBots.Patches.ModPatches.ReviveCompany;
using LethalBots.Patches.ModPatches.ShowCapacity;
using LethalBots.Patches.ModPatches.TooManyEmotes;
using LethalBots.Patches.ModPatches.UsualScrap;
using LethalBots.Patches.ModPatches.Zaprillator;
using LethalBots.Patches.NpcPatches;
using LethalBots.Patches.ObjectsPatches;
using LethalBots.SaveAdapter;
using LethalBots.Utils;
using LethalBots.Utils.Helpers;
using LethalCompanyInputUtils.Api;
using LethalInternship.AI;
using LethalInternship.Managers;
using LethalLib.Modules;
using LethalMin;
using Microsoft.CodeAnalysis;
using ModelReplacement;
using ModelReplacement.Monobehaviors;
using ModelReplacement.Patches;
using MoreCompany;
using MoreCompany.Cosmetics;
using MoreEmotes.Patch;
using MoreEmotes.Scripts;
using Newtonsoft.Json;
using OPJosMod.ReviveCompany;
using OPJosMod.ReviveCompany.CustomRpc;
using ReservedItemSlotCore;
using ReservedItemSlotCore.Data;
using ReservedItemSlotCore.Patches;
using Scoops.gameobjects;
using Scoops.misc;
using Scoops.patch;
using Scoops.service;
using SpeechRecognitionAPI;
using Steamworks;
using TMPro;
using TooManyEmotes;
using TooManyEmotes.Networking;
using TooManyEmotes.Patches;
using Unity.AI.Navigation;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.Animations.Rigging;
using UnityEngine.Audio;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.Networking;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using UsualScrap.Behaviors;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("LethalBots")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("7.0.3.0")]
[assembly: AssemblyInformationalVersion("7.0.3+bdb7f050db062d432bc5e608ac4d6f67e56e6ad9")]
[assembly: AssemblyProduct("LethalBots")]
[assembly: AssemblyTitle("LethalBots")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("7.0.3.0")]
[assembly: TypeForwardedTo(typeof(AllowNullAttribute))]
[assembly: TypeForwardedTo(typeof(DisallowNullAttribute))]
[assembly: TypeForwardedTo(typeof(MaybeNullAttribute))]
[assembly: TypeForwardedTo(typeof(MaybeNullWhenAttribute))]
[assembly: TypeForwardedTo(typeof(NotNullAttribute))]
[assembly: TypeForwardedTo(typeof(NotNullIfNotNullAttribute))]
[assembly: TypeForwardedTo(typeof(NotNullWhenAttribute))]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class IsUnmanagedAttribute : Attribute
{
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
[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 LethalBots
{
[BepInPlugin("T-Rizzle.LethalBots", "LethalBots", "7.0.3")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class Plugin : BaseUnityPlugin
{
public const string ModGUID = "T-Rizzle.LethalBots";
public static AssetBundle ModAssets;
public static AssetBundle ShipOrbitNavMeshAssets;
internal static string DirectoryName;
internal static EnemyType LethalBotNPCPrefab;
internal static GameObject ShipOrbitNavMeshPrefab;
internal static int PluginIrlPlayersCount;
internal static ManualLogSource Logger;
internal static Config Config;
internal static LethalBotsInputs InputActionsInstance;
internal static bool IsModSpeechRecognitionAPILoaded;
internal static bool IsModTooManyEmotesLoaded;
internal static bool IsModModelReplacementAPILoaded;
internal static bool IsModCustomItemBehaviourLibraryLoaded;
internal static bool IsModMoreCompanyLoaded;
internal static bool IsModReviveCompanyLoaded;
internal static bool IsModBunkbedReviveLoaded;
internal static bool IsModZaprillatorLoaded;
internal static bool IsModLethalMinLoaded;
internal static bool IsModLethalInternsLoaded;
internal static bool IsModFacilityMeltdownLoaded;
internal static bool IsModNavmeshInCompanyLoaded;
internal static bool IsModReservedItemSlotCoreLoaded;
internal static bool IsModLethalPhonesLoaded;
internal static bool IsModGeneralImprovementsLoaded;
internal static bool IsModDawnLibLoaded;
internal static bool IsModUsualScrapLoaded;
private readonly Harmony _harmony = new Harmony("T-Rizzle.LethalBots");
private void Awake()
{
string text = "lethalbotnpcmodassets";
string path = "ship_orbit_navmesh";
DirectoryName = Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location);
Logger = ((BaseUnityPlugin)this).Logger;
Config = new Config(((BaseUnityPlugin)this).Config);
InputActionsInstance = new LethalBotsInputs();
InitializeNetworkBehaviours();
ModAssets = AssetBundle.LoadFromFile(Path.Combine(DirectoryName, text));
if ((Object)(object)ModAssets == (Object)null)
{
Logger.LogFatal((object)"Unknown to load custom assets.");
return;
}
LethalBotNPCPrefab = ModAssets.LoadAsset<EnemyType>("LethalBotNPC");
if ((Object)(object)LethalBotNPCPrefab == (Object)null)
{
Logger.LogInfo((object)"Failed to directly load LethalBotNPC, manually searching asset bundle instead!");
Object[] array = ModAssets.LoadAllAssets();
for (int i = 0; i < array.Length; i++)
{
Logger.LogInfo((object)$"Found {array[i]} in asset bundle");
Object obj = array[i];
EnemyType val = (EnemyType)(object)((obj is EnemyType) ? obj : null);
if (val != null)
{
LethalBotNPCPrefab = val;
break;
}
}
}
if ((Object)(object)LethalBotNPCPrefab == (Object)null)
{
Logger.LogFatal((object)"LethalBotNPC prefab failed to load.");
return;
}
foreach (Transform item in (from x in LethalBotNPCPrefab.enemyPrefab.GetComponentsInChildren<Transform>()
where (Object)(object)x.parent != (Object)null && ((Object)x.parent).name == "LethalBotNPCObj" && ((Object)x).name != "Collision" && ((Object)x).name != "TurnCompass" && ((Object)x).name != "CreatureSFX" && ((Object)x).name != "CreatureVoice"
select x).ToList())
{
Object.DestroyImmediate((Object)(object)((Component)item).gameObject);
}
byte[] value = MD5.Create().ComputeHash(Encoding.UTF8.GetBytes(typeof(Plugin).Assembly.GetName().Name + ((Object)((Component)this).gameObject).name + text));
uint num = BitConverter.ToUInt32(value, 0);
Type typeFromHandle = typeof(NetworkObject);
FieldInfo field = typeFromHandle.GetField("GlobalObjectIdHash", BindingFlags.Instance | BindingFlags.NonPublic);
NetworkObject component = LethalBotNPCPrefab.enemyPrefab.GetComponent<NetworkObject>();
field.SetValue(component, num);
ShipOrbitNavMeshAssets = AssetBundle.LoadFromFile(Path.Combine(DirectoryName, path));
if ((Object)(object)ShipOrbitNavMeshAssets == (Object)null)
{
Logger.LogFatal((object)"Unknown to load custom ship navmesh assests.");
return;
}
ShipOrbitNavMeshPrefab = ShipOrbitNavMeshAssets.LoadAsset<GameObject>("ShipNavMeshColliders");
if ((Object)(object)ShipOrbitNavMeshPrefab == (Object)null)
{
Logger.LogFatal((object)"ShipOrbitNavMesh prefab failed to load.");
return;
}
NetworkPrefabs.RegisterNetworkPrefab(LethalBotNPCPrefab.enemyPrefab);
InitPluginManager();
PatchBaseGame();
PatchOtherMods();
Logger.LogInfo((object)"Plugin LethalBots is loaded!");
}
private void PatchBaseGame()
{
_harmony.PatchAll(typeof(AudioMixerPatch));
_harmony.PatchAll(typeof(AudioReverbTriggerPatch));
_harmony.PatchAll(typeof(DebugPatch));
_harmony.PatchAll(typeof(GameNetworkManagerPatch));
_harmony.PatchAll(typeof(HUDManagerPatch));
_harmony.PatchAll(typeof(NetworkSceneManagerPatch));
_harmony.PatchAll(typeof(NfgoPlayerPatch));
_harmony.PatchAll(typeof(NetworkObjectPatch));
_harmony.PatchAll(typeof(RoundManagerPatch));
_harmony.PatchAll(typeof(SoundManagerPatch));
_harmony.PatchAll(typeof(StartOfRoundPatch));
_harmony.PatchAll(typeof(EnemyAIPatch));
_harmony.PatchAll(typeof(PlayerControllerBPatch));
_harmony.PatchAll(typeof(EnemyAICollisionDetect));
_harmony.PatchAll(typeof(BaboonBirdAIPatch));
_harmony.PatchAll(typeof(BlobAIPatch));
_harmony.PatchAll(typeof(BushWolfEnemyPatch));
_harmony.PatchAll(typeof(ButlerBeesEnemyAIPatch));
_harmony.PatchAll(typeof(ButlerEnemyAIPatch));
_harmony.PatchAll(typeof(CadaverBloomAIPatch));
_harmony.PatchAll(typeof(CadaverGrowthAIPatch));
_harmony.PatchAll(typeof(CaveDwellerAIPatch));
_harmony.PatchAll(typeof(CentipedeAIPatch));
_harmony.PatchAll(typeof(CrawlerAIPatch));
_harmony.PatchAll(typeof(DressGirlAIPatch));
_harmony.PatchAll(typeof(FlowermanAIPatch));
_harmony.PatchAll(typeof(FlowerSnakeEnemyPatch));
_harmony.PatchAll(typeof(ForestGiantAIPatch));
_harmony.PatchAll(typeof(GiantKiwiAIPatch));
_harmony.PatchAll(typeof(JesterAIPatch));
_harmony.PatchAll(typeof(MaskedPlayerEnemyPatch));
_harmony.PatchAll(typeof(MouthDogAIPatch));
_harmony.PatchAll(typeof(NutcrackerEnemyAIPatch));
_harmony.PatchAll(typeof(PumaAIPatch));
_harmony.PatchAll(typeof(RadMechAIPatch));
_harmony.PatchAll(typeof(RadMechMissilePatch));
_harmony.PatchAll(typeof(RedLocustBeesPatch));
_harmony.PatchAll(typeof(SandSpiderAIPatch));
_harmony.PatchAll(typeof(SandWormAIPatch));
_harmony.PatchAll(typeof(SpringManAIPatch));
_harmony.PatchAll(typeof(LandminePatch));
_harmony.PatchAll(typeof(QuicksandTriggerPatch));
_harmony.PatchAll(typeof(SpikeRoofTrapPatch));
_harmony.PatchAll(typeof(TurretPatch));
_harmony.PatchAll(typeof(AnimatedObjectFloatSetterPatch));
_harmony.PatchAll(typeof(CompanyMonsterCollisionDetectPatch));
_harmony.PatchAll(typeof(DoorLockPatch));
_harmony.PatchAll(typeof(InteractTriggerPatch));
_harmony.PatchAll(typeof(OutOfBoundsTriggerPatch));
_harmony.PatchAll(typeof(ShipTeleporterPatch));
_harmony.PatchAll(typeof(VehicleControllerPatch));
_harmony.PatchAll(typeof(DepositItemsDeskPatch));
_harmony.PatchAll(typeof(CaveDwellerPhysicsPropPatch));
_harmony.PatchAll(typeof(DeadBodyInfoPatch));
_harmony.PatchAll(typeof(GrabbableObjectPatch));
_harmony.PatchAll(typeof(RagdollGrabbableObjectPatch));
_harmony.PatchAll(typeof(ShotgunItemPatch));
_harmony.PatchAll(typeof(SprayPaintItemPatch));
_harmony.PatchAll(typeof(StunGrenadeItemPatch));
_harmony.PatchAll(typeof(TetraChemicalItemPatch));
}
private void PatchOtherMods()
{
//IL_0213: Unknown result type (might be due to invalid IL or missing references)
//IL_0221: Expected O, but got Unknown
//IL_0250: Unknown result type (might be due to invalid IL or missing references)
//IL_025c: Expected O, but got Unknown
//IL_028b: Unknown result type (might be due to invalid IL or missing references)
//IL_0297: Expected O, but got Unknown
//IL_03a1: Unknown result type (might be due to invalid IL or missing references)
//IL_03ad: Expected O, but got Unknown
//IL_03dd: Unknown result type (might be due to invalid IL or missing references)
//IL_03eb: Expected O, but got Unknown
//IL_0457: Unknown result type (might be due to invalid IL or missing references)
//IL_0465: Expected O, but got Unknown
//IL_0498: Unknown result type (might be due to invalid IL or missing references)
//IL_04a6: Expected O, but got Unknown
//IL_04d3: Unknown result type (might be due to invalid IL or missing references)
//IL_04e1: Expected O, but got Unknown
//IL_050e: Unknown result type (might be due to invalid IL or missing references)
//IL_051c: Expected O, but got Unknown
//IL_0549: Unknown result type (might be due to invalid IL or missing references)
//IL_0557: Expected O, but got Unknown
//IL_0584: Unknown result type (might be due to invalid IL or missing references)
//IL_0592: Expected O, but got Unknown
//IL_05df: Unknown result type (might be due to invalid IL or missing references)
//IL_05ed: Expected O, but got Unknown
//IL_061a: Unknown result type (might be due to invalid IL or missing references)
//IL_0628: Expected O, but got Unknown
//IL_0655: Unknown result type (might be due to invalid IL or missing references)
//IL_0663: Expected O, but got Unknown
//IL_0690: Unknown result type (might be due to invalid IL or missing references)
//IL_069e: Expected O, but got Unknown
IsModSpeechRecognitionAPILoaded = IsModLoaded("JS03.SpeechRecognitionAPI");
IsModTooManyEmotesLoaded = IsModLoaded("FlipMods.TooManyEmotes");
IsModModelReplacementAPILoaded = IsModLoaded("meow.ModelReplacementAPI");
IsModCustomItemBehaviourLibraryLoaded = IsModLoaded("com.github.WhiteSpike.CustomItemBehaviourLibrary");
IsModMoreCompanyLoaded = IsModLoaded("me.swipez.melonloader.morecompany");
IsModReviveCompanyLoaded = IsModLoaded("OpJosMod.ReviveCompany");
IsModBunkbedReviveLoaded = IsModLoaded("viviko.BunkbedRevive");
IsModZaprillatorLoaded = IsModLoaded("Zaprillator");
IsModLethalMinLoaded = IsModLoaded("NoteBoxz.LethalMin");
IsModLethalInternsLoaded = IsModLoaded("Szumi57.LethalInterns");
IsModFacilityMeltdownLoaded = IsModLoaded("me.loaforc.facilitymeltdown");
IsModNavmeshInCompanyLoaded = IsModLoaded("dev.kittenji.NavMeshInCompany");
IsModReservedItemSlotCoreLoaded = IsModLoaded("FlipMods.ReservedItemSlotCore");
IsModLethalPhonesLoaded = IsModLoaded("LethalPhones");
IsModGeneralImprovementsLoaded = IsModLoaded("ShaosilGaming.GeneralImprovements");
IsModDawnLibLoaded = IsModLoaded("com.github.teamxiaolan.dawnlib");
IsModUsualScrapLoaded = IsModLoaded("Emil.UsualScrap");
bool flag = IsModLoaded("MoreEmotes");
bool flag2 = IsModLoaded("BetterEmotes");
bool flag3 = IsModLoaded("Piggy.ShowCapacity");
bool flag4 = IsModLoaded("Stoneman.LethalProgression");
bool flag5 = IsModLoaded("suskitech.LCAlwaysHearActiveWalkie");
bool flag6 = IsModLoaded("butterystancakes.lethalcompany.butteryfixes");
bool flag7 = IsModLoaded("x753.Peepers");
bool flag8 = IsModLoaded("io.daxcess.lcvr");
List<string> list = new List<string>();
string[] files = Directory.GetFiles(Path.GetFullPath(Paths.PatcherPluginPath), "*.dll", SearchOption.AllDirectories);
foreach (string path in files)
{
list.Add(Path.GetFileName(path));
}
bool flag9 = IsPreLoaderLoaded("AdditionalNetworking_Preloader.dll", list);
if (flag)
{
_harmony.PatchAll(typeof(MoreEmotesPatch));
}
if (flag2)
{
_harmony.Patch((MethodBase)AccessTools.Method(AccessTools.TypeByName("BetterEmote.Patches.EmotePatch"), "StartPostfix", (Type[])null, (Type[])null), new HarmonyMethod(typeof(BetterEmotesPatch), "StartPostfix_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
_harmony.Patch((MethodBase)AccessTools.Method(AccessTools.TypeByName("BetterEmote.Patches.EmotePatch"), "UpdatePostfix", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(BetterEmotesPatch), "UpdatePostfix_Transpiler", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null);
_harmony.Patch((MethodBase)AccessTools.Method(AccessTools.TypeByName("BetterEmote.Patches.EmotePatch"), "PerformEmotePrefix", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(BetterEmotesPatch), "PerformEmotePrefix_Transpiler", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null);
_harmony.PatchAll(typeof(BetterEmotesCustomAnimationObjectsPatch));
}
if (IsModTooManyEmotesLoaded)
{
_harmony.PatchAll(typeof(EmoteControllerPlayerPatch));
_harmony.PatchAll(typeof(ThirdPersonEmoteControllerPatch));
}
if (IsModModelReplacementAPILoaded)
{
_harmony.PatchAll(typeof(ModelReplacementPlayerControllerBPatchPatch));
_harmony.PatchAll(typeof(ModelReplacementAPIPatch));
}
if (IsModLethalPhonesLoaded)
{
_harmony.PatchAll(typeof(AudioSourceStoragePatch));
_harmony.PatchAll(typeof(PhoneBehaviorPatch));
_harmony.PatchAll(typeof(PlayerPhonePatch));
_harmony.PatchAll(typeof(PlayerPhonePatchPatch));
PhoneBehaviorPatch.SetupReflectionFields();
}
if (flag9)
{
_harmony.Patch((MethodBase)AccessTools.Method(AccessTools.TypeByName("AdditionalNetworking.Patches.Inventory.PlayerControllerBPatch"), "OnStart", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(AdditionalNetworkingPatch), "Start_Transpiler", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null);
}
if (flag3)
{
_harmony.Patch((MethodBase)AccessTools.Method(AccessTools.TypeByName("ShowCapacity.Patches.PlayerControllerBPatch"), "Update_PostFix", (Type[])null, (Type[])null), new HarmonyMethod(typeof(ShowCapacityPatch), "Update_PostFix_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
}
if (IsModReviveCompanyLoaded)
{
_harmony.PatchAll(typeof(ReviveCompanyGeneralUtilPatch));
}
if (IsModBunkbedReviveLoaded)
{
_harmony.PatchAll(typeof(BunkbedControllerPatch));
}
if (IsModZaprillatorLoaded)
{
_harmony.Patch((MethodBase)AccessTools.Method(AccessTools.TypeByName("Zaprillator.Behaviors.RevivablePlayer"), "IShockableWithGun.StopShockingWithGun", (Type[])null, (Type[])null), new HarmonyMethod(typeof(RevivablePlayerPatch), "StopShockingWithGun_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
}
if (flag4)
{
_harmony.Patch((MethodBase)AccessTools.Method(AccessTools.TypeByName("LethalProgression.Skills.HPRegen"), "HPRegenUpdate", (Type[])null, (Type[])null), new HarmonyMethod(typeof(HPRegenPatch), "HPRegenUpdate_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
_harmony.Patch((MethodBase)AccessTools.Method(AccessTools.TypeByName("LethalProgression.Skills.Oxygen"), "EnteredWater", (Type[])null, (Type[])null), new HarmonyMethod(typeof(OxygenPatch), "EnteredWater_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
_harmony.Patch((MethodBase)AccessTools.Method(AccessTools.TypeByName("LethalProgression.Skills.Oxygen"), "LeftWater", (Type[])null, (Type[])null), new HarmonyMethod(typeof(OxygenPatch), "LeftWater_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
_harmony.Patch((MethodBase)AccessTools.Method(AccessTools.TypeByName("LethalProgression.Skills.Oxygen"), "ShouldDrown", (Type[])null, (Type[])null), new HarmonyMethod(typeof(OxygenPatch), "ShouldDrown_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
_harmony.Patch((MethodBase)AccessTools.Method(AccessTools.TypeByName("LethalProgression.Skills.Oxygen"), "OxygenUpdate", (Type[])null, (Type[])null), new HarmonyMethod(typeof(OxygenPatch), "OxygenUpdate_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
}
if (flag7)
{
_harmony.PatchAll(typeof(PeeperAttachHitboxPatch));
}
if (flag8)
{
_harmony.Patch((MethodBase)AccessTools.Method(AccessTools.TypeByName("LCVR.Patches.Spectating.SpectatorPlayerPatches"), "BeforePlayerDeath", (Type[])null, (Type[])null), new HarmonyMethod(typeof(LCVRPatchesPatch), "BeforePlayerDeath_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
_harmony.Patch((MethodBase)AccessTools.Method(AccessTools.TypeByName("LCVR.Patches.Spectating.SpectatorPlayerPatches"), "OnPlayerDeath", (Type[])null, (Type[])null), new HarmonyMethod(typeof(LCVRPatchesPatch), "OnPlayerDeath_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
_harmony.Patch((MethodBase)AccessTools.Method(AccessTools.TypeByName("LCVR.Patches.Items.ShotgunItemPatches"), "DisplaySafetyPatch", (Type[])null, (Type[])null), new HarmonyMethod(typeof(LCVRPatchesPatch), "DisplaySafetyPatch_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
_harmony.Patch((MethodBase)AccessTools.Method(AccessTools.TypeByName("LCVR.Patches.PlayerControllerPatches"), "AfterDamagePlayer", (Type[])null, (Type[])null), new HarmonyMethod(typeof(LCVRPatchesPatch), "AfterDamagePlayer_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
}
if (IsModDawnLibLoaded)
{
_harmony.PatchAll(typeof(DawnMoonNetworkerPatch));
}
if (IsModUsualScrapLoaded)
{
_harmony.PatchAll(typeof(DefibrillatorScriptPatch));
}
}
private bool IsModLoaded(string modGUID)
{
bool flag = Chainloader.PluginInfos.ContainsKey(modGUID);
if (flag)
{
LogInfo("Mod compatibility loaded for mod : GUID " + modGUID);
}
return flag;
}
private bool IsPreLoaderLoaded(string dllFileName, List<string> fileNames)
{
bool flag = fileNames.Contains(dllFileName);
if (flag)
{
LogInfo("Mod compatibility loaded for preloader : " + dllFileName);
}
return flag;
}
private static void InitializeNetworkBehaviours()
{
Type[] types = Assembly.GetExecutingAssembly().GetTypes();
Type[] array = types;
foreach (Type type in array)
{
MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
MethodInfo[] array2 = methods;
foreach (MethodInfo methodInfo in array2)
{
try
{
object[] customAttributes = methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false);
if (customAttributes.Length != 0)
{
methodInfo.Invoke(null, null);
}
}
catch
{
}
}
}
}
private static void InitPluginManager()
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_000b: Expected O, but got Unknown
GameObject val = new GameObject("PluginManager");
val.AddComponent<PluginManager>();
PluginManager.Instance.InitManagers();
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void LogDebug(string debugLog)
{
if (Config.EnableDebugLog.Value)
{
Logger.LogDebug((object)debugLog);
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void LogInfo(string infoLog)
{
Logger.LogInfo((object)infoLog);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void LogWarning(string warningLog)
{
Logger.LogWarning((object)warningLog);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void LogError(string errorLog)
{
Logger.LogError((object)errorLog);
}
}
public static class MyPluginInfo
{
public const string PLUGIN_GUID = "LethalBots";
public const string PLUGIN_NAME = "LethalBots";
public const string PLUGIN_VERSION = "7.0.3";
}
}
namespace LethalBots.Utils
{
internal static class ComponentUtil
{
public static void ListAllComponents(GameObject gameObject)
{
if ((Object)(object)gameObject == (Object)null)
{
return;
}
Plugin.LogDebug(" ");
Plugin.LogDebug("List of components :");
Component[] components = gameObject.GetComponents(typeof(Component));
Component[] array = components;
foreach (Component val in array)
{
if (!((Object)(object)val == (Object)null))
{
Plugin.LogDebug(((object)val).ToString());
}
}
Plugin.LogDebug("Child components :");
components = gameObject.GetComponentsInChildren(typeof(Component));
Component[] array2 = components;
foreach (Component val2 in array2)
{
if (!((Object)(object)val2 == (Object)null))
{
Plugin.LogDebug(((object)val2).ToString());
}
}
Plugin.LogDebug("Parent components :");
components = gameObject.GetComponentsInParent(typeof(Component));
Component[] array3 = components;
foreach (Component val3 in array3)
{
if (!((Object)(object)val3 == (Object)null))
{
Plugin.LogDebug(((object)val3).ToString());
}
}
}
public static void ListAllColliders(GameObject gameObject)
{
if ((Object)(object)gameObject == (Object)null)
{
return;
}
Plugin.LogDebug(" ");
Plugin.LogDebug("List of Colliders: ");
Component[] components = gameObject.GetComponents(typeof(Collider));
Component[] array = components;
foreach (Component val in array)
{
if (!((Object)(object)val == (Object)null))
{
Plugin.LogDebug(((object)val).ToString());
}
}
Plugin.LogDebug("Child Colliders: ");
components = gameObject.GetComponentsInChildren(typeof(Collider));
Component[] array2 = components;
foreach (Component val2 in array2)
{
if (!((Object)(object)val2 == (Object)null))
{
Plugin.LogDebug(((object)val2).ToString());
}
}
Plugin.LogDebug("Parent Colliders: ");
components = gameObject.GetComponentsInParent(typeof(Collider));
Component[] array3 = components;
foreach (Component val3 in array3)
{
if (!((Object)(object)val3 == (Object)null))
{
Plugin.LogDebug(((object)val3).ToString());
}
}
}
public static void SetFieldValue(object obj, string fieldName, object value)
{
Type type = obj.GetType();
FieldInfo field = type.GetField(fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
field.SetValue(obj, value);
}
public static void SetPropertyValue(object obj, string propertyName, object value)
{
Type type = obj.GetType();
PropertyInfo property = type.GetProperty(propertyName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
property.SetValue(obj, value);
}
public static T GetCopyOf<T>(this Component comp, T other) where T : Component
{
Type type = ((object)comp).GetType();
if (type != ((object)other).GetType())
{
return default(T);
}
BindingFlags bindingAttr = BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
PropertyInfo[] properties = type.GetProperties(bindingAttr);
PropertyInfo[] array = properties;
foreach (PropertyInfo propertyInfo in array)
{
if (propertyInfo.CanWrite && propertyInfo.CanRead && !(propertyInfo.Name == "name"))
{
try
{
propertyInfo.SetValue(comp, propertyInfo.GetValue(other, null), null);
}
catch
{
}
}
}
FieldInfo[] allFields = PropertiesAndFieldsUtils.GetAllFields(type);
FieldInfo[] array2 = allFields;
foreach (FieldInfo fieldInfo in array2)
{
if (!fieldInfo.IsStatic)
{
fieldInfo.SetValue(comp, fieldInfo.GetValue(other));
}
}
return (T)(object)((comp is T) ? comp : null);
}
public static T AddCopyOfComponent<T>(this GameObject go, T toAdd) where T : Component
{
return ((Component)(object)go.AddComponent<T>()).GetCopyOf(toAdd);
}
public static T CopyComponent<T>(T original, GameObject destination) where T : Component
{
Type type = ((object)original).GetType();
Component component = destination.GetComponent(type);
T val = (T)(object)((component is T) ? component : null);
if (!Object.op_Implicit((Object)(object)val))
{
Component obj = destination.AddComponent(type);
val = (T)(object)((obj is T) ? obj : null);
}
FieldInfo[] allFields = PropertiesAndFieldsUtils.GetAllFields(type);
FieldInfo[] array = allFields;
foreach (FieldInfo fieldInfo in array)
{
if (!fieldInfo.IsStatic)
{
fieldInfo.SetValue(val, fieldInfo.GetValue(original));
}
}
PropertyInfo[] properties = type.GetProperties();
PropertyInfo[] array2 = properties;
foreach (PropertyInfo propertyInfo in array2)
{
if (propertyInfo.CanWrite && propertyInfo.CanWrite && !(propertyInfo.Name == "name"))
{
propertyInfo.SetValue(val, propertyInfo.GetValue(original, null), null);
}
}
return val;
}
}
internal static class DrawUtil
{
public static void DrawWhiteLine(LineRenderer? lr, Ray ray, float length)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
DrawLine(lr, ray, length, Color.white);
}
public static void DrawLine(LineRenderer? lr, Ray ray, float length, Color color)
{
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//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_0019: 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_0029: Unknown result type (might be due to invalid IL or missing references)
Vector3 origin = ((Ray)(ref ray)).origin;
Vector3 origin2 = ((Ray)(ref ray)).origin;
Vector3 direction = ((Ray)(ref ray)).direction;
DrawLine(lr, origin, origin2 + ((Vector3)(ref direction)).normalized * length, color);
}
public static void DrawLine(LineRenderer? lr, Vector3 start, Vector3 end, Color color)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Expected O, but got Unknown
//IL_0020: 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_0045: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)lr == (Object)null))
{
((Renderer)lr).material = new Material(Shader.Find("Legacy Shaders/Particles/Alpha Blended Premultiply"));
lr.startColor = color;
lr.endColor = color;
lr.startWidth = 0.1f;
lr.endWidth = 0.1f;
lr.SetPosition(0, start);
lr.SetPosition(1, end);
}
}
}
public class LineRendererUtil
{
private LineRenderer[] _listLineRenderers;
private Transform _transformToParent;
private int _index;
public LineRendererUtil(int nbMaxLineRenderer, Transform transformToParent)
{
_listLineRenderers = (LineRenderer[])(object)new LineRenderer[nbMaxLineRenderer];
_transformToParent = transformToParent;
}
public LineRenderer? GetLineRenderer()
{
return null;
}
private LineRenderer CreateLineRenderer()
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
LineRenderer lineRenderer = new GameObject().AddComponent<LineRenderer>();
return InitLineRenderer(ref lineRenderer);
}
private LineRenderer InitLineRenderer(ref LineRenderer lineRenderer)
{
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
((Component)lineRenderer).gameObject.transform.SetParent(((Component)_transformToParent).transform, false);
((Component)lineRenderer).gameObject.transform.SetPositionAndRotation(Vector3.zero, Quaternion.identity);
return lineRenderer;
}
}
internal static class PatchesUtil
{
public static readonly FieldInfo FieldInfoWasUnderwaterLastFrame = AccessTools.Field(typeof(PlayerControllerB), "wasUnderwaterLastFrame");
public static readonly FieldInfo FieldInfoPlayerClientId = AccessTools.Field(typeof(PlayerControllerB), "playerClientId");
public static readonly FieldInfo FieldInfoPreviousAnimationStateHash = AccessTools.Field(typeof(PlayerControllerB), "previousAnimationStateHash");
public static readonly FieldInfo FieldInfoCurrentAnimationStateHash = AccessTools.Field(typeof(PlayerControllerB), "currentAnimationStateHash");
public static readonly FieldInfo FieldInfoTargetPlayer = AccessTools.Field(typeof(EnemyAI), "targetPlayer");
public static readonly FieldInfo FieldInfoDraggingPlayer = AccessTools.Field(typeof(BushWolfEnemy), "draggingPlayer");
public static readonly FieldRef<Terminal, bool> usedTerminalThisSessionField = (FieldRef<Terminal, bool>)(object)AccessTools.FieldRefAccess<bool>(typeof(Terminal), "usedTerminalThisSession");
public static readonly FieldRef<Terminal, bool> syncedTerminalValuesField = (FieldRef<Terminal, bool>)(object)AccessTools.FieldRefAccess<bool>(typeof(Terminal), "syncedTerminalValues");
public static readonly FieldRef<Terminal, int> totalCostOfItemsField = (FieldRef<Terminal, int>)(object)AccessTools.FieldRefAccess<int>(typeof(Terminal), "totalCostOfItems");
public static readonly FieldRef<Terminal, bool> broadcastedCodeThisFrameField = (FieldRef<Terminal, bool>)(object)AccessTools.FieldRefAccess<bool>(typeof(Terminal), "broadcastedCodeThisFrame");
public static readonly FieldRef<Terminal, bool> hasGottenNounField = (FieldRef<Terminal, bool>)(object)AccessTools.FieldRefAccess<bool>(typeof(Terminal), "hasGottenNoun");
public static readonly FieldRef<Terminal, bool> hasGottenVerbField = (FieldRef<Terminal, bool>)(object)AccessTools.FieldRefAccess<bool>(typeof(Terminal), "hasGottenVerb");
public static readonly FieldRef<Terminal, InteractTrigger> terminalTriggerField = (FieldRef<Terminal, InteractTrigger>)(object)AccessTools.FieldRefAccess<InteractTrigger>(typeof(Terminal), "terminalTrigger");
public static readonly FieldRef<ItemDropship, List<int>> itemsToDeliverField = (FieldRef<ItemDropship, List<int>>)(object)AccessTools.FieldRefAccess<List<int>>(typeof(ItemDropship), "itemsToDeliver");
public static readonly FieldRef<PlayerControllerB, Vector3> positionOfDeathField = (FieldRef<PlayerControllerB, Vector3>)(object)AccessTools.FieldRefAccess<Vector3>(typeof(PlayerControllerB), "positionOfDeath");
public static readonly FieldRef<PlayerControllerB, float> timeSinceSwitchingSlotsField = (FieldRef<PlayerControllerB, float>)(object)AccessTools.FieldRefAccess<float>(typeof(PlayerControllerB), "timeSinceSwitchingSlots");
public static readonly FieldRef<PlayerControllerB, float> slimeSlipAudioVolumeSyncField = (FieldRef<PlayerControllerB, float>)(object)AccessTools.FieldRefAccess<float>(typeof(PlayerControllerB), "slimeSlipAudioVolumeSync");
public static readonly FieldRef<EntranceTeleport, InteractTrigger> triggerScriptField = (FieldRef<EntranceTeleport, InteractTrigger>)(object)AccessTools.FieldRefAccess<InteractTrigger>(typeof(EntranceTeleport), "triggerScript");
public static readonly MethodInfo PlayerLoadedServerRpcMethod = AccessTools.Method(typeof(StartOfRound), "PlayerLoadedServerRpc", (Type[])null, (Type[])null);
public static readonly MethodInfo KillPlayerServerRpcMethod = AccessTools.Method(typeof(PlayerControllerB), "KillPlayerServerRpc", (Type[])null, (Type[])null);
public static readonly MethodInfo AllEntitiesCountMethod = SymbolExtensions.GetMethodInfo((Expression<Action>)(() => AllEntitiesCount()));
public static readonly MethodInfo AllRealPlayersCountMethod = SymbolExtensions.GetMethodInfo((Expression<Action>)(() => AllRealPlayersCount()));
public static readonly MethodInfo IsPlayerLocalOrLethalBotOwnerLocalMethod = SymbolExtensions.GetMethodInfo(Expression.Lambda<Action>(Expression.Call(null, (MethodInfo)MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), Expression.New(typeof(PlayerControllerB))), Array.Empty<ParameterExpression>()));
public static readonly MethodInfo IsPlayerLocalOrLethalBotMethod = SymbolExtensions.GetMethodInfo(Expression.Lambda<Action>(Expression.Call(null, (MethodInfo)MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), Expression.New(typeof(PlayerControllerB))), Array.Empty<ParameterExpression>()));
public static readonly MethodInfo IsColliderFromLocalOrLethalBotOwnerLocalMethod = SymbolExtensions.GetMethodInfo(Expression.Lambda<Action>(Expression.Call(null, (MethodInfo)MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), Expression.New(typeof(Collider))), Array.Empty<ParameterExpression>()));
public static readonly MethodInfo IsPlayerLethalBotMethod = SymbolExtensions.GetMethodInfo(Expression.Lambda<Action>(Expression.Call(null, (MethodInfo)MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), Expression.New(typeof(PlayerControllerB))), Array.Empty<ParameterExpression>()));
public static readonly MethodInfo IsPlayerLocalMethod = SymbolExtensions.GetMethodInfo(Expression.Lambda<Action>(Expression.Call(null, (MethodInfo)MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), Expression.New(typeof(PlayerControllerB))), Array.Empty<ParameterExpression>()));
public static readonly MethodInfo IsIdPlayerLethalBotMethod = SymbolExtensions.GetMethodInfo((Expression<Action>)(() => IsIdPlayerLethalBot(0)));
public static readonly MethodInfo IsRagdollPlayerIdLethalBotMethod = SymbolExtensions.GetMethodInfo(Expression.Lambda<Action>(Expression.Call(null, (MethodInfo)MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), Expression.New(typeof(RagdollGrabbableObject))), Array.Empty<ParameterExpression>()));
public static readonly MethodInfo IsPlayerLethalBotOwnerLocalMethod = SymbolExtensions.GetMethodInfo(Expression.Lambda<Action>(Expression.Call(null, (MethodInfo)MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), Expression.New(typeof(PlayerControllerB))), Array.Empty<ParameterExpression>()));
public static readonly MethodInfo IsAnLethalBotAiOwnerOfObjectMethod = SymbolExtensions.GetMethodInfo((Expression<Action>)(() => IsAnLethalBotAiOwnerOfObject((GrabbableObject)new object())));
public static readonly MethodInfo DisableOriginalGameDebugLogsMethod = SymbolExtensions.GetMethodInfo((Expression<Action>)(() => DisableOriginalGameDebugLogs()));
public static readonly MethodInfo IsPlayerLethalBotControlledAndOwnerMethod = SymbolExtensions.GetMethodInfo(Expression.Lambda<Action>(Expression.Call(null, (MethodInfo)MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), Expression.New(typeof(PlayerControllerB))), Array.Empty<ParameterExpression>()));
public static readonly MethodInfo GetDamageFromSlimeIfLethalBotMethod = SymbolExtensions.GetMethodInfo(Expression.Lambda<Action>(Expression.Call(null, (MethodInfo)MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), Expression.New(typeof(PlayerControllerB))), Array.Empty<ParameterExpression>()));
public static readonly MethodInfo SyncJumpMethod = SymbolExtensions.GetMethodInfo((Expression<Action>)(() => SyncJump(0uL)));
public static readonly MethodInfo SyncLandFromJumpMethod = SymbolExtensions.GetMethodInfo((Expression<Action>)(() => SyncLandFromJump(0uL, fallHard: false)));
public static List<CodeInstruction> InsertIsPlayerLethalBotInstructions(List<CodeInstruction> codes, ILGenerator generator, int startIndex, int indexToJumpTo)
{
//IL_0088: Unknown result type (might be due to invalid IL or missing references)
//IL_0092: Expected O, but got Unknown
//IL_009d: Unknown result type (might be due to invalid IL or missing references)
//IL_00a7: Expected O, but got Unknown
//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
//IL_00bd: Expected O, but got Unknown
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_0059: Expected O, but got Unknown
List<Label> labels = codes[startIndex].labels;
List<Label> labels2 = codes[startIndex + indexToJumpTo].labels;
Label label = generator.DefineLabel();
labels2.Add(label);
if (labels.Count > 0)
{
codes.Insert(startIndex + 1, new CodeInstruction(codes[startIndex].opcode, codes[startIndex].operand));
codes[startIndex].opcode = OpCodes.Nop;
codes[startIndex].operand = null;
startIndex++;
}
List<CodeInstruction> collection = new List<CodeInstruction>
{
new CodeInstruction(OpCodes.Ldarg_0, (object)null),
new CodeInstruction(OpCodes.Call, (object)IsPlayerLethalBotMethod),
new CodeInstruction(OpCodes.Brtrue_S, (object)label)
};
codes.InsertRange(startIndex, collection);
return codes;
}
public static List<CodeInstruction> InsertLogOfFieldOfThis(string logWithZeroParameter, FieldInfo fieldInfo, Type fieldType)
{
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Expected O, but got Unknown
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: Expected O, but got Unknown
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
//IL_004c: Expected O, but got Unknown
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_005d: Expected O, but got Unknown
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
//IL_006e: Expected O, but got Unknown
//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
//IL_00ee: Expected O, but got Unknown
//IL_0152: Unknown result type (might be due to invalid IL or missing references)
//IL_015c: Expected O, but got Unknown
List<CodeInstruction> list = new List<CodeInstruction>();
list.Add(new CodeInstruction(OpCodes.Ldsfld, (object)AccessTools.Field(typeof(Plugin), "Logger")));
list.Add(new CodeInstruction(OpCodes.Ldstr, (object)logWithZeroParameter));
list.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
list.Add(new CodeInstruction(OpCodes.Ldfld, (object)fieldInfo));
list.Add(new CodeInstruction(OpCodes.Box, (object)fieldType));
list.Add(new CodeInstruction(OpCodes.Call, (object)SymbolExtensions.GetMethodInfo((Expression<Action>)(() => string.Format(new string(new char[0]), new object())))));
list.Add(new CodeInstruction(OpCodes.Callvirt, (object)SymbolExtensions.GetMethodInfo((Expression<Action>)(() => Plugin.LogDebug(new string(new char[0]))))));
return list;
}
public static List<CodeInstruction> InsertLogWithoutParameters(string log)
{
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Expected O, but got Unknown
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: Expected O, but got Unknown
//IL_009f: Unknown result type (might be due to invalid IL or missing references)
//IL_00a9: Expected O, but got Unknown
List<CodeInstruction> list = new List<CodeInstruction>();
list.Add(new CodeInstruction(OpCodes.Ldsfld, (object)AccessTools.Field(typeof(Plugin), "Logger")));
list.Add(new CodeInstruction(OpCodes.Ldstr, (object)log));
list.Add(new CodeInstruction(OpCodes.Callvirt, (object)SymbolExtensions.GetMethodInfo((Expression<Action>)(() => Plugin.LogDebug(new string(new char[0]))))));
return list;
}
public static List<CodeInstruction> InsertIsBypass(List<CodeInstruction> codes, ILGenerator generator, int startIndex, int indexToJumpTo)
{
//IL_008c: Unknown result type (might be due to invalid IL or missing references)
//IL_0096: Expected O, but got Unknown
//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
//IL_00ac: Expected O, but got Unknown
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_0059: Expected O, but got Unknown
List<Label> labels = codes[startIndex].labels;
List<Label> labels2 = codes[startIndex + indexToJumpTo].labels;
Label label = generator.DefineLabel();
labels2.Add(label);
if (labels.Count > 0)
{
codes.Insert(startIndex + 1, new CodeInstruction(codes[startIndex].opcode, codes[startIndex].operand));
codes[startIndex].opcode = OpCodes.Nop;
codes[startIndex].operand = null;
startIndex++;
}
List<CodeInstruction> collection = new List<CodeInstruction>
{
new CodeInstruction(OpCodes.Call, (object)DisableOriginalGameDebugLogsMethod),
new CodeInstruction(OpCodes.Brtrue_S, (object)label)
};
codes.InsertRange(startIndex, collection);
return codes;
}
public static bool IsGrabbableObjectEqualsToNull(GrabbableObject grabbableObject)
{
return (Object)(object)grabbableObject == (Object)null;
}
private static bool DisableOriginalGameDebugLogs()
{
return false;
}
private static bool IsPlayerLocal(PlayerControllerB player)
{
return LethalBotManager.IsPlayerLocal(player);
}
private static bool IsPlayerLocalOrLethalBot(PlayerControllerB player)
{
return LethalBotManager.Instance.IsPlayerLocalOrLethalBot(player);
}
private static bool IsPlayerLocalOrLethalBotOwnerLocal(PlayerControllerB player)
{
return LethalBotManager.Instance.IsPlayerLocalOrLethalBotOwnerLocal(player);
}
private static int AllEntitiesCount()
{
return LethalBotManager.Instance.AllEntitiesCount;
}
private static int AllRealPlayersCount()
{
return Math.Clamp(LethalBotManager.Instance.AllRealPlayersCount - 1, 0, AllEntitiesCount());
}
private static bool IsColliderFromLocalOrLethalBotOwnerLocal(Collider collider)
{
return LethalBotManager.Instance.IsColliderFromLocalOrLethalBotOwnerLocal(collider);
}
private static bool IsPlayerLethalBot(PlayerControllerB player)
{
return LethalBotManager.Instance.IsPlayerLethalBot(player);
}
private static bool IsIdPlayerLethalBot(int id)
{
return LethalBotManager.Instance.IsPlayerLethalBot(id);
}
private static bool IsRagdollPlayerIdLethalBot(RagdollGrabbableObject ragdollGrabbableObject)
{
return LethalBotManager.Instance.IsPlayerLethalBot((int)ragdollGrabbableObject.ragdoll.playerScript.playerClientId);
}
private static bool IsPlayerLethalBotOwnerLocal(PlayerControllerB player)
{
return LethalBotManager.Instance.IsPlayerLethalBotOwnerLocal(player);
}
private static bool IsPlayerLethalBotControlledAndOwner(PlayerControllerB player)
{
return LethalBotManager.Instance.IsPlayerLethalBotControlledAndOwner(player);
}
private static int GetDamageFromSlimeIfLethalBot(PlayerControllerB player)
{
return LethalBotManager.Instance.GetDamageFromSlimeIfLethalBot(player);
}
private static bool IsAnLethalBotAiOwnerOfObject(GrabbableObject grabbableObject)
{
return LethalBotManager.Instance.IsAnLethalBotAiOwnerOfObject(grabbableObject);
}
private static void SyncJump(ulong playerClientId)
{
LethalBotManager.Instance.GetLethalBotAI((int)playerClientId)?.SyncJump();
}
private static void SyncLandFromJump(ulong playerClientId, bool fallHard)
{
LethalBotManager.Instance.GetLethalBotAI((int)playerClientId)?.SyncLandFromJump(fallHard);
}
}
internal static class PropertiesAndFieldsUtils
{
public static void ListNamesOfObjectsArray<T>(T[] array)
{
Type typeFromHandle = typeof(T);
Plugin.LogDebug(" ");
if (array == null)
{
Plugin.LogDebug($"Array of type {typeFromHandle} is null");
return;
}
if (array.Length == 0)
{
Plugin.LogDebug($"Array of type {typeFromHandle} is empty");
return;
}
PropertyInfo[] readablePropertiesOf = GetReadablePropertiesOf(typeFromHandle);
Plugin.LogDebug($"- List of type : {typeFromHandle}");
for (int i = 0; i < array.Length; i++)
{
T val = array[i];
if (val != null)
{
Plugin.LogDebug($" Object {i}: \"{NameOfObject(val, readablePropertiesOf)}\"");
}
}
}
public static void ListPropertiesAndFieldsOfArray<T>(T[] array, bool hasToListProperties = true, bool hasToListFields = true)
{
Type typeFromHandle = typeof(T);
if (array == null)
{
Plugin.LogDebug($"Array of type {typeFromHandle} is null");
return;
}
if (array.Length == 0)
{
Plugin.LogDebug($"Array of type {typeFromHandle} is empty");
return;
}
PropertyInfo[] readablePropertiesOf = GetReadablePropertiesOf(typeFromHandle);
FieldInfo[] allFields = GetAllFields(typeFromHandle);
for (int i = 0; i < array.Length; i++)
{
if (hasToListProperties)
{
LogProperties(array[i], typeFromHandle, readablePropertiesOf);
}
Plugin.LogDebug(" ");
Plugin.LogDebug($"- Fields of \"{NameOfObject(array[i], readablePropertiesOf)}\" of type \"{typeFromHandle}\" :");
if (hasToListFields)
{
LogFields(array[i], typeFromHandle, allFields);
}
}
}
public static void ListPropertiesAndFields<T>(T obj, bool hasToListProperties = true, bool hasToListFields = true)
{
Type typeFromHandle = typeof(T);
PropertyInfo[] readablePropertiesOf = GetReadablePropertiesOf(typeFromHandle);
if (hasToListProperties)
{
LogProperties(obj, typeFromHandle, readablePropertiesOf);
}
Plugin.LogDebug(" ");
Plugin.LogDebug($"- Fields of \"{NameOfObject(obj, readablePropertiesOf)}\" of type \"{typeFromHandle}\" :");
FieldInfo[] allFields = GetAllFields(typeFromHandle);
if (hasToListFields)
{
LogFields(obj, typeFromHandle, allFields);
}
}
public static NetworkObject? GetNetworkObjectByHash(uint hashID)
{
FieldInfo field = typeof(NetworkObject).GetField("GlobalObjectIdHash", BindingFlags.Instance | BindingFlags.NonPublic);
if (field == null)
{
Plugin.LogError("GlobalObjectIdHash field is null.");
return null;
}
NetworkObject[] array = Resources.FindObjectsOfTypeAll<NetworkObject>();
foreach (NetworkObject val in array)
{
uint num = (uint)field.GetValue(val);
if (num == hashID)
{
return val;
}
}
return null;
}
private static void LogProperties<T>(T obj, Type typeObj, PropertyInfo[] arrObjProperties)
{
if (obj == null)
{
Plugin.LogDebug($"Object of type {typeObj} is null");
return;
}
Plugin.LogDebug(" ");
Plugin.LogDebug($"- Properties of \"{NameOfObject(obj, arrObjProperties)}\" of type \"{typeObj}\" :");
foreach (PropertyInfo propertyInfo in arrObjProperties)
{
Plugin.LogDebug($" {propertyInfo.Name} = {GetValueOfProperty(obj, propertyInfo)}");
}
}
private static string NameOfObject<T>(T obj, PropertyInfo[] propertyInfos)
{
object valueOfProperty = GetValueOfProperty(obj, propertyInfos.FirstOrDefault((PropertyInfo x) => x.Name == "name"));
if (valueOfProperty != null)
{
return valueOfProperty.ToString();
}
return "name null";
}
private static void LogFields<T>(T obj, Type typeObj, FieldInfo[] arrObjFields)
{
if (obj == null)
{
Plugin.LogDebug($"Object of type {typeObj} is null");
return;
}
Plugin.LogDebug(" ");
foreach (FieldInfo fieldInfo in arrObjFields)
{
Plugin.LogDebug($" {fieldInfo.Name} = {GetValueOfField(obj, fieldInfo)}");
}
}
public static FieldInfo[] GetAllFields(Type t)
{
if (t == null)
{
return new FieldInfo[0];
}
BindingFlags bindingAttr = BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
return t.GetFields(bindingAttr).Concat(GetAllFields(t.BaseType)).ToArray();
}
private static PropertyInfo[] GetReadablePropertiesOf(Type type)
{
return (from x in type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy)
where x.CanRead
select x).ToArray();
}
private static object? GetValueOfProperty<T>(T obj, PropertyInfo propertyInfo)
{
if (propertyInfo == null)
{
return null;
}
if (!propertyInfo.GetAccessors(nonPublic: true)[0].IsStatic)
{
return propertyInfo.GetValue(obj, null);
}
return propertyInfo.GetValue(null);
}
private static object? GetValueOfField<T>(T obj, FieldInfo fieldInfo)
{
if (fieldInfo == null)
{
return null;
}
if (!fieldInfo.IsStatic)
{
return fieldInfo.GetValue(obj);
}
return fieldInfo.GetValue(null);
}
}
public class RayUtil
{
public static void RayCastAndDrawFromPointWithColor(LineRenderer? lr, Vector3 origin, Vector3 endPoint, Color color)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
//IL_0004: Unknown result type (might be due to invalid IL or missing references)
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: 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_001a: Unknown result type (might be due to invalid IL or missing references)
Ray ray = default(Ray);
((Ray)(ref ray))..ctor(origin, endPoint - origin);
float length = Vector3.Distance(endPoint, origin);
DrawUtil.DrawLine(lr, ray, length, color);
}
public static bool RayCastAndDraw(LineRenderer? lr, Vector3 origin, Vector3 directionOrigin, float angle, float length)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0001: 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)
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: 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_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: 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_0029: 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_0034: Unknown result type (might be due to invalid IL or missing references)
//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)
//IL_005a: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
Vector3 val = Vector3.Cross(directionOrigin, Vector3.up);
if (val == Vector3.zero)
{
val = Vector3.right;
}
Ray val2 = default(Ray);
((Ray)(ref val2))..ctor(origin, Quaternion.AngleAxis(angle, val) * directionOrigin);
if (Physics.Raycast(val2, length, StartOfRound.Instance.walkableSurfacesMask, (QueryTriggerInteraction)1))
{
DrawUtil.DrawLine(lr, val2, length, Color.red);
return true;
}
DrawUtil.DrawWhiteLine(lr, val2, length);
return false;
}
public static bool RayCastForwardAndDraw(LineRenderer? lr, Vector3 origin, Vector3 directionForward, float length)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_002d: 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)
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
Ray val = default(Ray);
((Ray)(ref val))..ctor(origin, directionForward);
if (Physics.Raycast(val, length, StartOfRound.Instance.walkableSurfacesMask, (QueryTriggerInteraction)1))
{
DrawUtil.DrawLine(lr, val, length, Color.red);
return true;
}
DrawUtil.DrawWhiteLine(lr, val, length);
return false;
}
public static bool RayCastDownAndDraw(LineRenderer? lr, Vector3 origin, float length)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0003: 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_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: 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)
Ray val = default(Ray);
((Ray)(ref val))..ctor(origin, Vector3.down);
if (Physics.Raycast(val, length, StartOfRound.Instance.walkableSurfacesMask, (QueryTriggerInteraction)1))
{
DrawUtil.DrawLine(lr, val, length, Color.red);
return true;
}
DrawUtil.DrawWhiteLine(lr, val, length);
return false;
}
}
internal static class TreesUtils
{
public static void PrintTransformTree(Transform[] tree, string? parent = null)
{
if (tree == null)
{
Plugin.LogDebug("Tree of transform is null");
return;
}
if (tree.Length == 0)
{
Plugin.LogDebug("Tree of transform is empty");
return;
}
if (Utility.IsNullOrWhiteSpace(parent))
{
Transform? obj = tree.FirstOrDefault();
object obj2;
if (obj == null)
{
obj2 = null;
}
else
{
Transform parent2 = obj.parent;
if (parent2 == null)
{
obj2 = null;
}
else
{
Transform root = parent2.root;
obj2 = ((root != null) ? ((Object)root).name : null);
}
}
parent = (string?)obj2;
}
TransformTreeTraversal(tree, parent, 0);
}
private static void TransformTreeTraversal(Transform[] tree, string? parent, int depth)
{
StringBuilder stringBuilder = new StringBuilder();
foreach (Transform val in tree)
{
if ((string.IsNullOrWhiteSpace(parent) && ((Object)(object)val.parent == (Object)null || string.IsNullOrWhiteSpace(((Object)val.parent).name))) || ((Object)(object)val.parent != (Object)null && ((Object)val.parent).name == parent))
{
for (int j = 1; j <= depth - 1; j++)
{
stringBuilder.Append("│ ");
}
if (depth > 0)
{
stringBuilder.Append("├──");
}
Plugin.LogDebug(stringBuilder.ToString() + ((Object)val).name);
stringBuilder.Clear();
TransformTreeTraversal(tree, ((Object)val).name, depth + 1);
}
}
}
public static void PrintComponentsTreeOfGameObject(GameObject gameObject)
{
if ((Object)(object)gameObject == (Object)null)
{
Plugin.LogDebug("GameObject is null");
return;
}
Component[] array = (from x in gameObject.GetComponentsInChildren(typeof(Component))
where (Object)(object)x != (Object)null
select x).ToArray();
if (array.Length == 0)
{
Plugin.LogDebug("GameObject has no components");
}
else
{
ComponentTreeTraversal(array);
}
}
private static int ComponentTreeTraversal(Component[] tree, string? parent = null, int index = 0, int depth = 0, string lastTransformName = "")
{
StringBuilder stringBuilder = new StringBuilder();
for (int i = index; i < tree.Length; i++)
{
Component val = tree[i];
Transform val2 = (Transform)(object)((val is Transform) ? val : null);
bool flag = (Object)(object)val2 != (Object)null;
if ((Object)(object)val2 == (Object)null)
{
val2 = val.transform;
}
if (string.IsNullOrWhiteSpace(parent))
{
Transform parent2 = val2.parent;
if (string.IsNullOrWhiteSpace((parent2 != null) ? ((Object)parent2).name : null))
{
Plugin.LogDebug((flag ? ((Object)val2).name : ((object)val).ToString()) ?? "");
}
}
if (string.IsNullOrWhiteSpace(parent))
{
Transform parent3 = val2.parent;
if (!string.IsNullOrWhiteSpace((parent3 != null) ? ((Object)parent3).name : null))
{
parent = ((Object)val2.parent).name;
}
}
if (parent == ((Object)val2).name)
{
for (int j = 1; j <= depth - 1; j++)
{
stringBuilder.Append("│ ");
}
if (depth > 0)
{
stringBuilder.Append("├──");
}
Plugin.LogDebug($"{stringBuilder}{(flag ? ((Object)val2).name : ((object)val).ToString())}");
stringBuilder.Clear();
continue;
}
Transform parent4 = val2.parent;
if (((parent4 != null) ? ((Object)parent4).name : null) == parent && flag)
{
for (int k = 1; k <= depth - 1; k++)
{
stringBuilder.Append("│ ");
}
if (depth > 0)
{
stringBuilder.Append("├──");
}
if (!(((Object)val2).name == lastTransformName))
{
lastTransformName = ((Object)val2).name;
Plugin.LogDebug($"{stringBuilder}{((Object)val2).name}");
stringBuilder.Clear();
i = ComponentTreeTraversal(tree, ((Object)val2).name, i + 1, depth + 1, lastTransformName);
index = i;
}
}
}
return index;
}
}
}
namespace LethalBots.Utils.Helpers
{
public class ChatCommand
{
public string Keyword;
public Func<AIState, LethalBotAI, PlayerControllerB, string, bool, bool> Execute;
public ChatCommand(string keyword, Func<AIState, LethalBotAI, PlayerControllerB, string, bool, bool> execute)
{
Keyword = keyword.ToLower();
Execute = execute;
}
}
[Serializable]
public class CountdownTimer : INetworkSerializable, IEquatable<CountdownTimer>
{
public float startTime = -1f;
public float endTime = -1f;
public void Reset()
{
startTime = -1f;
endTime = -1f;
}
public void Start(float time)
{
startTime = Time.realtimeSinceStartup;
endTime = Time.realtimeSinceStartup + ((time >= 0f) ? time : 0f);
}
public bool HasStarted()
{
return endTime > 0f;
}
public float GetElapsedTime()
{
if (!HasStarted())
{
return -1f;
}
return Time.realtimeSinceStartup - startTime;
}
public bool Elapsed()
{
if (HasStarted())
{
return endTime <= Time.realtimeSinceStartup;
}
return false;
}
public CountdownTimer Clone()
{
return new CountdownTimer
{
startTime = startTime,
endTime = endTime
};
}
public unsafe void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
{
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
((BufferSerializer<float>*)(&serializer))->SerializeValue<float>(ref startTime, default(ForPrimitives));
((BufferSerializer<float>*)(&serializer))->SerializeValue<float>(ref endTime, default(ForPrimitives));
}
public bool Equals(CountdownTimer other)
{
if (startTime == other.startTime)
{
return endTime == other.endTime;
}
return false;
}
public override bool Equals(object? obj)
{
if (obj is CountdownTimer other)
{
return Equals(other);
}
return false;
}
public override int GetHashCode()
{
return HashCode.Combine(startTime, endTime);
}
public static bool operator ==(CountdownTimer? left, CountdownTimer? right)
{
if ((object)left == right)
{
return true;
}
if ((object)left == null || (object)right == null)
{
return false;
}
return left.Equals(right);
}
public static bool operator !=(CountdownTimer? left, CountdownTimer? right)
{
return !(left == right);
}
}
public class DunGenTileTracker : MonoBehaviour
{
[CompilerGenerated]
private sealed class <GetAllDoorsInDungeon>d__38 : IEnumerable<Door>, IEnumerable, IEnumerator<Door>, IEnumerator, IDisposable
{
private int <>1__state;
private Door <>2__current;
private int <>l__initialThreadId;
private Dungeon dungeon;
public Dungeon <>3__dungeon;
private IEnumerator<GameObject> <>7__wrap1;
Door IEnumerator<Door>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <GetAllDoorsInDungeon>d__38(int <>1__state)
{
this.<>1__state = <>1__state;
<>l__initialThreadId = Environment.CurrentManagedThreadId;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
int num = <>1__state;
if (num == -3 || num == 1)
{
try
{
}
finally
{
<>m__Finally1();
}
}
<>7__wrap1 = null;
<>1__state = -2;
}
private bool MoveNext()
{
try
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>7__wrap1 = dungeon.Doors.GetEnumerator();
<>1__state = -3;
break;
case 1:
<>1__state = -3;
break;
}
while (<>7__wrap1.MoveNext())
{
GameObject current = <>7__wrap1.Current;
if ((Object)(object)current != (Object)null)
{
Door component = current.GetComponent<Door>();
if ((Object)(object)component != (Object)null)
{
<>2__current = component;
<>1__state = 1;
return true;
}
}
}
<>m__Finally1();
<>7__wrap1 = null;
return false;
}
catch
{
//try-fault
((IDisposable)this).Dispose();
throw;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
private void <>m__Finally1()
{
<>1__state = -1;
if (<>7__wrap1 != null)
{
<>7__wrap1.Dispose();
}
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
[DebuggerHidden]
IEnumerator<Door> IEnumerable<Door>.GetEnumerator()
{
<GetAllDoorsInDungeon>d__38 <GetAllDoorsInDungeon>d__;
if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
{
<>1__state = 0;
<GetAllDoorsInDungeon>d__ = this;
}
else
{
<GetAllDoorsInDungeon>d__ = new <GetAllDoorsInDungeon>d__38(0);
}
<GetAllDoorsInDungeon>d__.dungeon = <>3__dungeon;
return <GetAllDoorsInDungeon>d__;
}
[DebuggerHidden]
IEnumerator IEnumerable.GetEnumerator()
{
return ((IEnumerable<Door>)this).GetEnumerator();
}
}
private readonly UpdateLimiter updateLimiter = new UpdateLimiter();
public int AdjacentTileDepth = 1;
public bool CullBehindClosedDoors = true;
public Transform? TargetOverride;
public bool IncludeDisabledComponents;
private Tag? disableCullingTag;
protected List<Dungeon> dungeons = new List<Dungeon>();
protected List<Tile> allTiles = new List<Tile>();
protected List<Door> allDoors = new List<Door>();
protected List<Tile> oldVisibleTiles = new List<Tile>();
protected List<Tile> visibleTiles = new List<Tile>();
protected Dictionary<Tile, bool> tileVisibilities = new Dictionary<Tile, bool>();
private bool dirty;
private DungeonGenerator generator;
public Tile? currentTile;
private Queue<Tile> tilesToSearch;
private List<Tile> searchedTiles;
public LethalBotAI lethalBotAI { get; internal set; }
public Tag DisableCullingTag
{
get
{
if (disableCullingTag == (Tag)null)
{
disableCullingTag = StartOfRound.Instance.occlusionCuller.DisableCullingTag;
}
return disableCullingTag;
}
set
{
disableCullingTag = value;
}
}
public bool Ready { get; protected set; }
protected Transform targetTransform
{
get
{
if ((Object)(object)TargetOverride == (Object)null)
{
return ((Component)this).transform;
}
return TargetOverride;
}
}
protected virtual void OnEnable()
{
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Expected O, but got Unknown
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_003f: Invalid comparison between Unknown and I4
RuntimeDungeon val = UnityUtil.FindObjectByType<RuntimeDungeon>();
if ((Object)(object)val != (Object)null)
{
generator = val.Generator;
generator.OnGenerationComplete += new DungeonGenerationDelegate(OnDungeonGenerationComplete);
if ((int)generator.Status == 8)
{
AddDungeon(generator.CurrentDungeon);
}
}
}
protected virtual void OnDisable()
{
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Expected O, but got Unknown
if (generator != null)
{
generator.OnGenerationComplete -= new DungeonGenerationDelegate(OnDungeonGenerationComplete);
}
for (int i = 0; i < allTiles.Count; i++)
{
if ((Object)(object)allTiles[i] != (Object)null)
{
SetTileVisibility(allTiles[i], visible: true);
}
}
ClearAllDungeons();
}
public virtual void SetDungeon(Dungeon newDungeon)
{
if ((Object)(object)newDungeon != (Object)null)
{
ClearAllDungeons();
AddDungeon(newDungeon);
}
}
public virtual void AddDungeon(Dungeon? dungeon)
{
//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
//IL_00c6: Expected O, but got Unknown
if ((Object)(object)dungeon == (Object)null || dungeons.Contains(dungeon))
{
return;
}
dungeons.Add(dungeon);
List<Tile> list = new List<Tile>(dungeon.AllTiles);
List<Door> list2 = new List<Door>(GetAllDoorsInDungeon(dungeon));
allTiles.AddRange(list);
allDoors.AddRange(list2);
foreach (Tile item in list)
{
if (!item.Tags.Tags.Contains(DisableCullingTag))
{
SetTileVisibility(item, visible: false);
}
}
foreach (Door item2 in list2)
{
item2.OnDoorStateChanged += new DoorStateChangedDelegate(OnDoorStateChanged);
}
Ready = true;
dirty = true;
}
private void RemoveNullKeys<TKey, TValue>(ref Dictionary<TKey, TValue> dictionary)
{
TKey[] array = dictionary.Keys.Where((TKey val) => val == null).ToArray();
TKey[] array2 = array;
foreach (TKey key in array2)
{
if (dictionary.ContainsKey(key))
{
dictionary.Remove(key);
}
}
}
public virtual void RemoveDungeon(Dungeon dungeon)
{
//IL_0149: Unknown result type (might be due to invalid IL or missing references)
//IL_0153: Expected O, but got Unknown
if ((Object)(object)dungeon == (Object)null || !dungeons.Contains(dungeon))
{
return;
}
dungeons.Remove(dungeon);
allTiles.RemoveAll((Tile x) => !Object.op_Implicit((Object)(object)x));
visibleTiles.RemoveAll((Tile x) => !Object.op_Implicit((Object)(object)x));
allDoors.RemoveAll((Door x) => !Object.op_Implicit((Object)(object)x));
RemoveNullKeys(ref tileVisibilities);
foreach (Tile allTile in dungeon.AllTiles)
{
SetTileVisibility(allTile, visible: true);
allTiles.Remove(allTile);
tileVisibilities.Remove(allTile);
visibleTiles.Remove(allTile);
oldVisibleTiles.Remove(allTile);
}
Door val = default(Door);
foreach (GameObject door in dungeon.Doors)
{
if ((Object)(object)door != (Object)null && door.TryGetComponent<Door>(ref val))
{
val.OnDoorStateChanged -= new DoorStateChangedDelegate(OnDoorStateChanged);
allDoors.Remove(val);
}
}
if (allTiles.Count == 0)
{
Ready = false;
}
}
public virtual void ClearAllDungeons()
{
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Expected O, but got Unknown
Ready = false;
foreach (Door allDoor in allDoors)
{
if ((Object)(object)allDoor != (Object)null)
{
allDoor.OnDoorStateChanged -= new DoorStateChangedDelegate(OnDoorStateChanged);
}
}
dungeons.Clear();
allTiles.Clear();
visibleTiles.Clear();
allDoors.Clear();
oldVisibleTiles.Clear();
tileVisibilities.Clear();
}
public virtual bool IsTileVisible(Tile tile)
{
if (tileVisibilities.TryGetValue(tile, out var value))
{
return value;
}
return false;
}
[IteratorStateMachine(typeof(<GetAllDoorsInDungeon>d__38))]
protected IEnumerable<Door> GetAllDoorsInDungeon(Dungeon dungeon)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <GetAllDoorsInDungeon>d__38(-2)
{
<>3__dungeon = dungeon
};
}
protected virtual void OnDoorStateChanged(Door door, bool isOpen)
{
dirty = true;
}
protected virtual void OnDungeonGenerationComplete(DungeonGenerator generator)
{
if ((generator.AttachmentSettings == null || generator.AttachmentSettings.TileProxy == null) && dungeons.Count > 0)
{
RemoveDungeon(dungeons[dungeons.Count - 1]);
}
AddDungeon(generator.CurrentDungeon);
}
protected virtual void LateUpdate()
{
//IL_007d: 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_008b: Unknown result type (might be due to invalid IL or missing references)
if (!Ready || !updateLimiter.CanUpdate())
{
return;
}
updateLimiter.SetUpdateInterval(((EnemyAI)lethalBotAI).AIIntervalTime);
updateLimiter.Invalidate();
if (!lethalBotAI.NpcController.Npc.isInsideFactory)
{
return;
}
Tile val = currentTile;
if ((Object)(object)currentTile == (Object)null)
{
currentTile = FindCurrentTile();
}
else
{
Bounds bounds = currentTile.Bounds;
if (!((Bounds)(ref bounds)).Contains(targetTransform.position))
{
currentTile = SearchForNewCurrentTile();
}
}
if ((Object)(object)currentTile != (Object)(object)val && (Object)(object)currentTile != (Object)null)
{
dirty = true;
}
if (dirty)
{
RefreshVisibility();
}
dirty = false;
}
public Tile? GetStartTile()
{
for (int i = 0; i < allTiles.Count; i++)
{
if (allTiles[i].Placement.NormalizedPathDepth == 0f)
{
return allTiles[i];
}
}
return null;
}
public void SetToStartTile()
{
if (!Ready)
{
return;
}
Tile val = currentTile;
if ((Object)(object)RoundManager.Instance.dungeonGenerator == (Object)null)
{
Plugin.LogError("RoundManager dungeon generator is null! Cannot set StartTile as current tile!");
return;
}
Tile val2 = RoundManager.Instance.dungeonGenerator.Generator.CurrentDungeon.MainPathTiles[0];
for (int i = 0; i < allTiles.Count; i++)
{
if ((Object)(object)allTiles[i] == (Object)(object)val2)
{
Plugin.LogInfo("DunGenTileTracker: Got start tile!");
currentTile = allTiles[i];
break;
}
}
if ((Object)(object)currentTile != (Object)(object)val && (Object)(object)currentTile != (Object)null)
{
dirty = true;
}
if (dirty)
{
RefreshVisibility();
}
dirty = false;
}
protected virtual void RefreshVisibility()
{
List<Tile> list = visibleTiles;
visibleTiles = oldVisibleTiles;
oldVisibleTiles = list;
UpdateVisibleTiles();
foreach (Tile oldVisibleTile in oldVisibleTiles)
{
if (!visibleTiles.Contains(oldVisibleTile) && !oldVisibleTile.Tags.Tags.Contains(DisableCullingTag))
{
SetTileVisibility(oldVisibleTile, visible: false);
}
}
foreach (Tile visibleTile in visibleTiles)
{
if (!oldVisibleTiles.Contains(visibleTile))
{
SetTileVisibility(visibleTile, visible: true);
}
}
oldVisibleTiles.Clear();
}
protected virtual void UpdateVisibleTiles()
{
visibleTiles.Clear();
if ((Object)(object)currentTile != (Object)null)
{
visibleTiles.Add(currentTile);
}
int num = 0;
for (int i = 0; i < AdjacentTileDepth; i++)
{
int count = visibleTiles.Count;
for (int j = num; j < count; j++)
{
foreach (Doorway usedDoorway in visibleTiles[j].UsedDoorways)
{
Tile tile = usedDoorway.ConnectedDoorway.Tile;
if ((Object)(object)tile == (Object)null || visibleTiles.Contains(tile))
{
continue;
}
if (CullBehindClosedDoors)
{
Door doorComponent = usedDoorway.DoorComponent;
if ((Object)(object)doorComponent != (Object)null && doorComponent.ShouldCullBehind)
{
continue;
}
}
visibleTiles.Add(tile);
}
}
num = count;
}
}
protected virtual void SetTileVisibility(Tile tile, bool visible)
{
tileVisibilities[tile] = visible;
}
protected Tile? FindCurrentTile()
{
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
foreach (Tile allTile in allTiles)
{
if ((Object)(object)allTile != (Object)null)
{
Bounds bounds = allTile.Bounds;
if (((Bounds)(ref bounds)).Contains(targetTransform.position))
{
return allTile;
}
}
}
return null;
}
protected Tile? SearchForNewCurrentTile()
{
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: 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_00f7: Unknown result type (might be due to invalid IL or missing references)
//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
//IL_0105: Unknown result type (might be due to invalid IL or missing references)
Bounds bounds;
if ((Object)(object)RoundManager.Instance.startRoomSpecialBounds != (Object)null)
{
bounds = RoundManager.Instance.startRoomSpecialBounds.bounds;
if (((Bounds)(ref bounds)).Contains(targetTransform.position))
{
Tile startTile = GetStartTile();
if ((Object)(object)startTile != (Object)null)
{
return startTile;
}
}
}
if (tilesToSearch == null)
{
tilesToSearch = new Queue<Tile>();
}
if (searchedTiles == null)
{
searchedTiles = new List<Tile>();
}
if ((Object)(object)currentTile == (Object)null)
{
return null;
}
foreach (Doorway usedDoorway in currentTile.UsedDoorways)
{
Tile tile = usedDoorway.ConnectedDoorway.Tile;
if ((Object)(object)tile != (Object)null && !tilesToSearch.Contains(tile))
{
tilesToSearch.Enqueue(tile);
}
}
while (tilesToSearch.Count > 0)
{
Tile val = tilesToSearch.Dequeue();
bounds = val.Bounds;
if (((Bounds)(ref bounds)).Contains(targetTransform.position))
{
tilesToSearch.Clear();
searchedTiles.Clear();
return val;
}
searchedTiles.Add(val);
foreach (Doorway usedDoorway2 in val.UsedDoorways)
{
Tile tile2 = usedDoorway2.ConnectedDoorway.Tile;
if ((Object)(object)tile2 != (Object)null && !tilesToSearch.Contains(tile2) && !searchedTiles.Contains(tile2))
{
tilesToSearch.Enqueue(tile2);
}
}
}
searchedTiles.Clear();
return null;
}
}
[Serializable]
public class IntervalTimer : INetworkSerializable, IEquatable<IntervalTimer>
{
public float timestamp = -1f;
public void Reset()
{
timestamp = Time.realtimeSinceStartup;
}
public void Start()
{
timestamp = Time.realtimeSinceStartup;
}
public void Invalidate()
{
timestamp = -1f;
}
public bool HasStarted()
{
return timestamp > 0f;
}
public float GetElapsedTime()
{
if (!HasStarted())
{
return -1f;
}
return Time.realtimeSinceStartup - timestamp;
}
public bool IsGreaterThan(float duration)
{
return GetElapsedTime() > duration;
}
public bool IsLessThan(float duration)
{
return GetElapsedTime() < duration;
}
public IntervalTimer Clone()
{
return new IntervalTimer
{
timestamp = timestamp
};
}
public unsafe void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
{
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
((BufferSerializer<float>*)(&serializer))->SerializeValue<float>(ref timestamp, default(ForPrimitives));
}
public bool Equals(IntervalTimer other)
{
return timestamp == other.timestamp;
}
public override bool Equals(object? obj)
{
if (obj is IntervalTimer other)
{
return Equals(other);
}
return false;
}
public override int GetHashCode()
{
return HashCode.Combine(timestamp);
}
public static bool operator ==(IntervalTimer? left, IntervalTimer? right)
{
if ((object)left == right)
{
return true;
}
if ((object)left == null || (object)right == null)
{
return false;
}
return left.Equals(right);
}
public static bool operator !=(IntervalTimer? left, IntervalTimer? right)
{
return !(left == right);
}
}
[Serializable]
public sealed class LethalBotInfection : INetworkSerializable, IEquatable<LethalBotInfection>
{
public float showSignsMeter;
public float timeAtLastHealing;
public float setPoison;
public float sprayOnPlayerMeter;
public float totalTimeSpentInPlants;
public bool stoodInWeedsLastCheck;
public float localPlayerImmunityTimer;
public unsafe void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
{
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: 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_0052: Unknown result type (might be due to invalid IL or missing references)
//IL_0062: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_0078: Unknown result type (might be due to invalid IL or missing references)
//IL_007e: Unknown result type (might be due to invalid IL or missing references)
//IL_008e: Unknown result type (might be due to invalid IL or missing references)
//IL_0094: Unknown result type (might be due to invalid IL or missing references)
((BufferSerializer<float>*)(&serializer))->SerializeValue<float>(ref showSignsMeter, default(ForPrimitives));
((BufferSerializer<float>*)(&serializer))->SerializeValue<float>(ref timeAtLastHealing, default(ForPrimitives));
((BufferSerializer<float>*)(&serializer))->SerializeValue<float>(ref setPoison, default(ForPrimitives));
((BufferSerializer<float>*)(&serializer))->SerializeValue<float>(ref sprayOnPlayerMeter, default(ForPrimitives));
((BufferSerializer<float>*)(&serializer))->SerializeValue<float>(ref totalTimeSpentInPlants, default(ForPrimitives));
((BufferSerializer<bool>*)(&serializer))->SerializeValue<bool>(ref stoodInWeedsLastCheck, default(ForPrimitives));
((BufferSerializer<float>*)(&serializer))->SerializeValue<float>(ref localPlayerImmunityTimer, default(ForPrimitives));
}
public bool Equals(LethalBotInfection? other)
{
if (other != null && showSignsMeter == other.showSignsMeter && timeAtLastHealing == other.timeAtLastHealing && setPoison == other.setPoison && sprayOnPlayerMeter == other.sprayOnPlayerMeter && totalTimeSpentInPlants == other.totalTimeSpentInPlants && stoodInWeedsLastCheck == other.stoodInWeedsLastCheck)
{
return localPlayerImmunityTimer == other.localPlayerImmunityTimer;
}
return false;
}
public override bool Equals(object obj)
{
if (obj is LethalBotInfection other)
{
return Equals(other);
}
return false;
}
public override int GetHashCode()
{
return HashCode.Combine(showSignsMeter, timeAtLastHealing, setPoison, sprayOnPlayerMeter, totalTimeSpentInPlants, stoodInWeedsLastCheck, localPlayerImmunityTimer);
}
public static bool operator ==(LethalBotInfection? left, LethalBotInfection? right)
{
if ((object)left == right)
{
return true;
}
if ((object)left == null || (object)right == null)
{
return false;
}
return left.Equals(right);
}
public static bool operator !=(LethalBotInfection? left, LethalBotInfection? right)
{
return !(left == right);
}
}
public class LethalBotInteraction
{
private InteractTrigger interactTrigger;
private Action<LethalBotAI, PlayerControllerB, InteractTrigger>? postInteractFunc;
private bool skipOriginalInteract;
private bool ignoreHandLimit;
private bool ignoreInteractablility;
public bool isBeingHeldByPlayer;
private float holdFillAmount;
public bool IsCompleted { get; private set; }
public LethalBotInteraction(InteractTrigger interactTrigger, bool ignoreInteractablility = false, bool ignoreHandLimit = false)
{
this.interactTrigger = interactTrigger;
this.ignoreHandLimit = ignoreHandLimit;
this.ignoreInteractablility = ignoreInteractablility;
skipOriginalInteract = false;
}
public LethalBotInteraction(InteractTrigger interactTrigger, Action<LethalBotAI, PlayerControllerB, InteractTrigger> postInteractFunc, bool ignoreInteractablility = false, bool skipOriginalInteract = false, bool ignoreHandLimit = false)
: this(interactTrigger, ignoreInteractablility, ignoreHandLimit)
{
this.postInteractFunc = postInteractFunc;
this.skipOriginalInteract = skipOriginalInteract;
}
public void Update(LethalBotAI lethalBotAI, float deltaTime)
{
if (IsCompleted)
{
return;
}
PlayerControllerB npc = lethalBotAI.NpcController.Npc;
if ((Object)(object)interactTrigger == (Object)null || (!ignoreInteractablility && !interactTrigger.interactable))
{
StopHoldInteractionOnTrigger();
return;
}
if (!((Component)interactTrigger).gameObject.activeInHierarchy || !interactTrigger.holdInteraction || interactTrigger.currentCooldownValue > 0f || (!ignoreHandLimit && npc.isHoldingObject && !interactTrigger.oneHandedItemAllowed) || (!ignoreHandLimit && npc.twoHanded && !interactTrigger.twoHandedItemAllowed))
{
StopHoldInteractionOnTrigger();
return;
}
if (!HoldInteractFill(deltaTime, interactTrigger.timeToHold, interactTrigger.timeToHoldSpeedMultiplier))
{
HoldInteractNotFilled();
return;
}
IsCompleted = true;
try
{
if (!skipOriginalInteract)
{
interactTrigger.Interact(npc.thisPlayerBody);
}
}
catch (Exception arg)
{
Plugin.LogError($"LethalBotInteraction had an error when calling interactTrigger.Interact on {interactTrigger}. Error: {arg}");
}
try
{
postInteractFunc?.Invoke(lethalBotAI, npc, interactTrigger);
}
catch (Exception arg2)
{
Plugin.LogError($"LethalBotInteraction had an error when calling postInteractFunc. Error: {arg2}");
}
}
private bool HoldInteractFill(float deltaTime, float timeToHold, float speedMultiplier = 1f)
{
if (timeToHold == -1f)
{
return false;
}
holdFillAmount += deltaTime * speedMultiplier;
if (holdFillAmount > timeToHold)
{
holdFillAmount = 0f;
return true;
}
return false;
}
private void HoldInteractNotFilled()
{
((UnityEvent<float>)(object)interactTrigger.holdingInteractEvent).Invoke(holdFillAmount / interactTrigger.timeToHold);
if (!interactTrigger.specialCharacterAnimation && !interactTrigger.isLadder)
{
if (!interactTrigger.isBeingHeldByPlayer && !isBeingHeldByPlayer)
{
((UnityEvent<PlayerControllerB>)(object)interactTrigger.onInteractEarly).Invoke((PlayerControllerB)null);
}
isBeingHeldByPlayer = true;
}
}
public void StopHoldInteractionOnTrigger()
{
if (!IsCompleted)
{
IsCompleted = true;
holdFillAmount = 0f;
if ((Object)(object)interactTrigger != (Object)null && isBeingHeldByPlayer && interactTrigger.currentCooldownValue <= 0f)
{
isBeingHeldByPlayer = false;
((UnityEvent<PlayerControllerB>)(object)interactTrigger.onStopInteract).Invoke((PlayerControllerB)null);
}
}
}
}
public sealed class Overrideable<T>
{
private T _value;
public bool IsOverridden { get; private set; }
public T Value
{
get
{
return _value;
}
set
{
_value = value;
IsOverridden = true;
}
}
internal Overrideable(T initialValue)
{
_value = initialValue;
IsOverridden = false;
}
public void Apply(T newValue)
{
if (!IsOverridden)
{
_value = newValue;
}
IsOverridden = false;
}
public static implicit operator T(Overrideable<T> overrideable)
{
return overrideable._value;
}
}
public class PriorityQueue<T>
{
private readonly Dictionary<QueuePriority, Queue<T>> _queues;
public int Count
{
get
{
int num = 0;
foreach (Queue<T> value in _queues.Values)
{
num += value.Count;
}
return num;
}
}
public PriorityQueue()
{
_queues = new Dictionary<QueuePriority, Queue<T>>
{
{
QueuePriority.Critical,
new Queue<T>()
},
{
QueuePriority.High,
new Queue<T>()
},
{
QueuePriority.Normal,
new Queue<T>()
},
{
QueuePriority.Low,
new Queue<T>()
}
};
}
public void Enqueue(T message, QueuePriority priority = QueuePriority.Low)
{
_queues[priority].Enqueue(message);
}
public bool TryDequeue(out T? message)
{
for (QueuePriority queuePriority = QueuePriority.Critical; queuePriority <= QueuePriority.Low; queuePriority++)
{
Queue<T> queue = _queues[queuePriority];
if (queue.TryDequeue(out message))
{
return true;
}
}
message = default(T);
return false;
}
public bool TryPeek(out T? message)
{
for (QueuePriority queuePriority = QueuePriority.Critical; queuePriority <= QueuePriority.Low; queuePriority++)
{
Queue<T> queue = _queues[queuePriority];
if (queue.TryPeek(out message))
{
return true;
}
}
message = default(T);
return false;
}
}
public class SignalTranslatorCommand
{
public string Keyword;
public Func<AIState, LethalBotAI, string, bool> Execute;
public SignalTranslatorCommand(string keyword, Func<AIState, LethalBotAI, string, bool> execute)
{
Keyword = keyword.ToLower();
Execute = execute;
}
}
public class UpdateLimiter
{
private static ConditionalWeakTable<EnemyAI, UpdateLimiter> nextUpdateList = new ConditionalWeakTable<EnemyAI, UpdateLimiter>();
private readonly CountdownTimer nextUpdateTimer = new CountdownTimer();
private float updateInterval;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static UpdateLimiter GetOrCreateMonitor(EnemyAI ai, float updateInterval = 0.5f)
{
return nextUpdateList.GetValue(ai, (EnemyAI _) => new UpdateLimiter(updateInterval));
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void RemoveMonitor(EnemyAI ai)
{
nextUpdateList.Remove(ai);
}
internal UpdateLimiter(float updateInterval = 0.5f)
{
this.updateInterval = updateInterval;
Invalidate();
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void SetUpdateInterval(float updateInterval)
{
this.updateInterval = updateInterval;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool CanUpdate()
{
if (nextUpdateTimer.HasStarted())
{
return nextUpdateTimer.Elapsed();
}
return true;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Invalidate()
{
nextUpdateTimer.Start(updateInterval);
}
}
}
namespace LethalBots.SaveAdapter
{
[Serializable]
public class SaveFile
{
public IdentitySaveFile[] IdentitiesSaveFiles;
public LethalBotBlacklistedItem[] BlacklistedItems;
}
[Serializable]
public class IdentitySaveFile
{
public int IdIdentity;
public int SuitID;
public int Hp;
public int Status;
public int XP;
public int Level;
public override string ToString()
{
return $"IdIdentity: {IdIdentity}, suitID {SuitID}, Hp {Hp}, XP {XP}, Level {Level}, Status {Status} {(EnumStatusIdentity)Status}";
}
}
[Serializable]
public class LethalBotBlacklistedItem
{
public string itemName;
public bool hasScrapValue;
public int scrapValue;
public float x;
public float y;
public float z;
[JsonIgnore]
public Vector3 SavedPosition
{
get
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
return new Vector3(x, y, z);
}
set
{
//IL_0001: 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_0019: Unknown result type (might be due to invalid IL or missing references)
x = value.x;
y = value.y;
z = value.z;
}
}
public LethalBotBlacklistedItem()
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
itemName = string.Empty;
SavedPosition = Vector3.zero;
hasScrapValue = false;
scrapValue = 0;
}
public LethalBotBlacklistedItem(GrabbableObject blacklistedItem)
{
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
itemName = blacklistedItem.itemProperties.itemName;
SavedPosition = ((Component)blacklistedItem).transform.position;
if (blacklistedItem.itemProperties.isScrap)
{
hasScrapValue = true;
scrapValue = blacklistedItem.scrapValue;
}
else
{
hasScrapValue = false;
scrapValue = 0;
}
}
public override string ToString()
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
return $"Blacklisted Item: {itemName}, Saved Position: {SavedPosition}, Scrap Value {scrapValue}";
}
}
}
namespace LethalBots.Properties
{
[GeneratedCode("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")]
[DebuggerNonUserCode]
[CompilerGenerated]
public class Resources
{
private static ResourceManager resourceMan;
private static CultureInfo resourceCulture;
[EditorBrowsable(EditorBrowsableState.Advanced)]
internal static ResourceManager ResourceManager
{
get
{
if (resourceMan == null)
{
ResourceManager resourceManager = new ResourceManager("LethalBot.Properties.Resources", typeof(Resources).Assembly);
resourceMan = resourceManager;
}
return resourceMan;
}
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
internal static CultureInfo Culture
{
get
{
return resourceCulture;
}
set
{
resourceCulture = value;
}
}
internal Resources()
{
}
}
}
namespace LethalBots.Patches.ObjectsPatches
{
[HarmonyPatch(typeof(CaveDwellerPhysicsProp))]
public class CaveDwellerPhysicsPropPatch
{
[HarmonyPatch("Start")]
[HarmonyPostfix]
private static void Start_Postfix(CaveDwellerPhysicsProp __instance)
{
LethalBotManager.Instance.GrabbableObjectSpawned((GrabbableObject)(object)__instance);
}
[HarmonyPatch("Update")]
[HarmonyPrefix]
private static bool Update_Prefix(CaveDwellerPhysicsProp __instance)
{
PlayerControllerB playerHeldBy = ((GrabbableObject)__instance).playerHeldBy;
CaveDwellerAI caveDwellerScript = __instance.caveDwellerScript;
if ((Object)(object)caveDwellerScript == (Object)null || (Object)(object)playerHeldBy == (Object)null)
{
return true;
}
LethalBotAI lethalBotAIIfLocalIsOwner = LethalBotManager.Instance.GetLethalBotAIIfLocalIsOwner(playerHeldBy);
if (((GrabbableObject)__instance).isHeld && (Object)(object)lethalBotAIIfLocalIsOwner != (Object)null && caveDwellerScript.rockingBaby > 0)
{
float value = lethalBotAIIfLocalIsOwner.FearLevel.Value;
if (caveDwellerScript.rockingBaby < 2 && value > 0.75f)
{
caveDwellerScript.rockingBaby = 2;
playerHeldBy.playerBodyAnimator.SetInteger("RockBaby", 2);
__instance.SetRockingBabyServerRpc(true);
}
else if (value < 0.6f && caveDwellerScript.rockingBaby > 2)
{
caveDwellerScript.rockingBaby = 1;
playerHeldBy.playerBodyAnimator.SetInteger("RockBaby", 1);
__instance.SetRockingBabyServerRpc(false);
}
}
return true;
}
[HarmonyPatch("DropBabyClientRpc")]
[HarmonyPrefix]
private static bool DropBabyClientRpc_Prefix(CaveDwellerAI __instance, int playerId)
{
LethalBotAI lethalBotAIIfLocalIsOwner = LethalBotManager.Instance.GetLethalBotAIIfLocalIsOwner(playerId);
if ((O
