using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Logging;
using Dissonance.Integrations.Unity_NFGO;
using GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Unity.AI.Navigation;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.AI;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyVersion("0.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace V81ErrorFix
{
internal static class NullRefGuard
{
private const int MaxWarningsPerKey = 5;
private static readonly Dictionary<string, int> WarningCounts = new Dictionary<string, int>();
internal static Exception Suppress(Exception exception, string key)
{
if (!(exception is NullReferenceException))
{
return exception;
}
WarningCounts.TryGetValue(key, out var value);
if (value < 5)
{
value++;
WarningCounts[key] = value;
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogWarning((object)$"Suppressed NullReferenceException in {key} ({value}/{5}); the object will safely retry on later updates.");
}
}
return null;
}
}
internal sealed class ParticleMeshShapeGuard : MonoBehaviour
{
private sealed class ParticleMeshWarningBatch
{
internal readonly string MeshName;
internal readonly string Reason;
internal readonly HashSet<string> ParticleSystemNames = new HashSet<string>();
internal ParticleMeshWarningBatch(string meshName, string reason)
{
MeshName = meshName;
Reason = reason;
}
}
private sealed class CachedMeshInspection
{
internal readonly Mesh Mesh;
internal readonly string InvalidReason;
internal CachedMeshInspection(Mesh mesh, string invalidReason)
{
Mesh = mesh;
InvalidReason = invalidReason;
}
}
private const float ScanInterval = 5f;
private const int ScanBatchSize = 64;
private const int MeshInspectionCacheCleanupThreshold = 256;
private float _nextScanTime;
private ParticleSystem[] _scanQueue;
private int _scanIndex;
private readonly HashSet<int> _patchedParticleSystems = new HashSet<int>();
private readonly WarningLimiter _warnings = new WarningLimiter();
private readonly Dictionary<string, ParticleMeshWarningBatch> _pendingWarnings = new Dictionary<string, ParticleMeshWarningBatch>();
private readonly Dictionary<int, CachedMeshInspection> _meshInspectionCache = new Dictionary<int, CachedMeshInspection>();
internal static void EnsureCreated()
{
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Expected O, but got Unknown
if (!((Object)(object)Object.FindObjectOfType<ParticleMeshShapeGuard>() != (Object)null))
{
GameObject val = new GameObject("V81ErrorFix.ParticleMeshShapeGuard");
Object.DontDestroyOnLoad((Object)(object)val);
((Object)val).hideFlags = (HideFlags)61;
val.AddComponent<ParticleMeshShapeGuard>();
}
}
private void Update()
{
if (_scanQueue != null)
{
ContinueParticleSystemScan();
}
else if (!(Time.realtimeSinceStartup < _nextScanTime))
{
_nextScanTime = Time.realtimeSinceStartup + 5f;
BeginParticleSystemScan();
ContinueParticleSystemScan();
}
}
private void BeginParticleSystemScan()
{
_pendingWarnings.Clear();
_scanQueue = Object.FindObjectsOfType<ParticleSystem>(true);
_scanIndex = 0;
}
private void ContinueParticleSystemScan()
{
if (_scanQueue != null)
{
int num = Math.Min(_scanIndex + 64, _scanQueue.Length);
while (_scanIndex < num)
{
TryPatchParticleSystem(_scanQueue[_scanIndex]);
_scanIndex++;
}
if (_scanIndex >= _scanQueue.Length)
{
_scanQueue = null;
_scanIndex = 0;
FlushParticleMeshWarnings();
}
}
}
private void TryPatchParticleSystem(ParticleSystem particleSystem)
{
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)particleSystem == (Object)null)
{
return;
}
int instanceID = ((Object)particleSystem).GetInstanceID();
if (_patchedParticleSystems.Contains(instanceID))
{
return;
}
try
{
ShapeModule shape = particleSystem.shape;
if (((ShapeModule)(ref shape)).enabled && TryGetShapeMesh(shape, out var mesh) && !((Object)(object)mesh == (Object)null))
{
string invalidMeshReasonCached = GetInvalidMeshReasonCached(mesh);
if (invalidMeshReasonCached != null)
{
((ShapeModule)(ref shape)).enabled = false;
_patchedParticleSystems.Add(instanceID);
QueueParticleMeshWarning(((Object)mesh).name, invalidMeshReasonCached, ((Object)particleSystem).name);
}
}
}
catch (Exception ex)
{
_patchedParticleSystems.Add(instanceID);
QueueParticleMeshWarning("inspection", "could not be inspected safely: " + ex.GetType().Name, ((Object)particleSystem).name);
}
}
private void QueueParticleMeshWarning(string meshName, string reason, string particleSystemName)
{
string key = meshName + "|" + reason;
if (_warnings.CanWarn(key))
{
if (!_pendingWarnings.TryGetValue(key, out var value))
{
value = new ParticleMeshWarningBatch(meshName, reason);
_pendingWarnings[key] = value;
}
value.ParticleSystemNames.Add(particleSystemName);
}
}
private void FlushParticleMeshWarnings()
{
foreach (KeyValuePair<string, ParticleMeshWarningBatch> pendingWarning in _pendingWarnings)
{
ParticleMeshWarningBatch warningBatch = pendingWarning.Value;
_warnings.Warn(pendingWarning.Key, delegate
{
string text = string.Join(", ", warningBatch.ParticleSystemNames);
return "Disabled mesh shape because mesh '" + warningBatch.MeshName + "' " + warningBatch.Reason + " on particle systems: " + text + ".";
});
}
}
private string GetInvalidMeshReasonCached(Mesh mesh)
{
int instanceID = ((Object)mesh).GetInstanceID();
if (_meshInspectionCache.TryGetValue(instanceID, out var value) && (Object)(object)value.Mesh == (Object)(object)mesh)
{
return value.InvalidReason;
}
string invalidMeshReason = GetInvalidMeshReason(mesh);
_meshInspectionCache[instanceID] = new CachedMeshInspection(mesh, invalidMeshReason);
CleanupMeshInspectionCacheIfNeeded();
return invalidMeshReason;
}
private void CleanupMeshInspectionCacheIfNeeded()
{
if (_meshInspectionCache.Count < 256)
{
return;
}
List<int> list = null;
foreach (KeyValuePair<int, CachedMeshInspection> item in _meshInspectionCache)
{
if (!((Object)(object)item.Value.Mesh != (Object)null))
{
if (list == null)
{
list = new List<int>();
}
list.Add(item.Key);
}
}
if (list != null)
{
for (int i = 0; i < list.Count; i++)
{
_meshInspectionCache.Remove(list[i]);
}
}
}
private static bool TryGetShapeMesh(ShapeModule shape, out Mesh mesh)
{
//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_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Invalid comparison between Unknown and I4
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Invalid comparison between Unknown and I4
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Invalid comparison between Unknown and I4
mesh = null;
ParticleSystemShapeType shapeType = ((ShapeModule)(ref shape)).shapeType;
ParticleSystemShapeType val = shapeType;
if ((int)val != 6)
{
if ((int)val != 13)
{
if ((int)val == 14)
{
mesh = (((Object)(object)((ShapeModule)(ref shape)).skinnedMeshRenderer != (Object)null) ? ((ShapeModule)(ref shape)).skinnedMeshRenderer.sharedMesh : null);
return (Object)(object)mesh != (Object)null;
}
return false;
}
object obj;
if (!((Object)(object)((ShapeModule)(ref shape)).meshRenderer != (Object)null))
{
obj = null;
}
else
{
MeshFilter component = ((Component)((ShapeModule)(ref shape)).meshRenderer).GetComponent<MeshFilter>();
obj = ((component != null) ? component.sharedMesh : null);
}
mesh = (Mesh)obj;
return (Object)(object)mesh != (Object)null;
}
mesh = ((ShapeModule)(ref shape)).mesh;
return (Object)(object)mesh != (Object)null;
}
private static string GetInvalidMeshReason(Mesh mesh)
{
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_0073: 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_0081: Unknown result type (might be due to invalid IL or missing references)
//IL_0086: Unknown result type (might be due to invalid IL or missing references)
//IL_008a: Unknown result type (might be due to invalid IL or missing references)
//IL_008c: 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_0093: Unknown result type (might be due to invalid IL or missing references)
//IL_0095: Unknown result type (might be due to invalid IL or missing references)
//IL_0097: Unknown result type (might be due to invalid IL or missing references)
//IL_009c: Unknown result type (might be due to invalid IL or missing references)
//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
if (!mesh.isReadable)
{
return "is not readable";
}
try
{
Vector3[] vertices = mesh.vertices;
int[] triangles = mesh.triangles;
if (vertices == null || triangles == null || vertices.Length == 0 || triangles.Length < 3)
{
return "has zero surface area";
}
double num = 0.0;
for (int i = 0; i + 2 < triangles.Length; i += 3)
{
Vector3 val = vertices[triangles[i]];
Vector3 val2 = vertices[triangles[i + 1]];
Vector3 val3 = vertices[triangles[i + 2]];
double num2 = num;
Vector3 val4 = Vector3.Cross(val2 - val, val3 - val);
num = num2 + (double)((Vector3)(ref val4)).magnitude * 0.5;
if (num > 0.0001)
{
return null;
}
}
}
catch
{
return "could not be inspected safely";
}
return "has zero surface area";
}
}
internal sealed class WarningLimiter
{
private readonly int _maxWarnings;
private readonly Dictionary<string, int> _warningCounts = new Dictionary<string, int>();
internal WarningLimiter(int maxWarnings = 5)
{
_maxWarnings = maxWarnings;
}
internal void Warn(string key, string message)
{
if (TryIncrement(key, out var warningCount))
{
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogWarning((object)$"{message} ({warningCount}/{_maxWarnings})");
}
}
}
internal void Warn(string key, Func<string> messageFactory)
{
if (TryIncrement(key, out var warningCount))
{
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogWarning((object)$"{messageFactory()} ({warningCount}/{_maxWarnings})");
}
}
}
internal bool CanWarn(string key)
{
_warningCounts.TryGetValue(key, out var value);
return value < _maxWarnings;
}
private bool TryIncrement(string key, out int warningCount)
{
_warningCounts.TryGetValue(key, out warningCount);
if (warningCount >= _maxWarnings)
{
return false;
}
warningCount++;
_warningCounts[key] = warningCount;
return true;
}
}
[HarmonyPatch]
internal static class DisabledAudioSourcePlayGuardPatch
{
[CompilerGenerated]
private sealed class <TargetMethods>d__2 : IEnumerable<MethodBase>, IEnumerable, IEnumerator<MethodBase>, IEnumerator, IDisposable
{
private int <>1__state;
private MethodBase <>2__current;
private int <>l__initialThreadId;
private MethodInfo[] <>s__1;
private int <>s__2;
private MethodInfo <method>5__3;
MethodBase IEnumerator<MethodBase>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <TargetMethods>d__2(int <>1__state)
{
this.<>1__state = <>1__state;
<>l__initialThreadId = Environment.CurrentManagedThreadId;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>s__1 = null;
<method>5__3 = null;
<>1__state = -2;
}
private bool MoveNext()
{
int num = <>1__state;
if (num != 0)
{
if (num != 1)
{
return false;
}
<>1__state = -1;
goto IL_00a4;
}
<>1__state = -1;
<>s__1 = typeof(AudioSource).GetMethods(BindingFlags.Instance | BindingFlags.Public);
<>s__2 = 0;
goto IL_00ba;
IL_00a4:
<method>5__3 = null;
<>s__2++;
goto IL_00ba;
IL_00ba:
if (<>s__2 < <>s__1.Length)
{
<method>5__3 = <>s__1[<>s__2];
if (<method>5__3.DeclaringType == typeof(AudioSource) && IsPlaybackMethod(<method>5__3))
{
<>2__current = <method>5__3;
<>1__state = 1;
return true;
}
goto IL_00a4;
}
<>s__1 = null;
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
[DebuggerHidden]
IEnumerator<MethodBase> IEnumerable<MethodBase>.GetEnumerator()
{
if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
{
<>1__state = 0;
return this;
}
return new <TargetMethods>d__2(0);
}
[DebuggerHidden]
IEnumerator IEnumerable.GetEnumerator()
{
return ((IEnumerable<MethodBase>)this).GetEnumerator();
}
}
private static readonly WarningLimiter Warnings = new WarningLimiter();
private static readonly WarningLimiter GuardFailureWarnings = new WarningLimiter();
[IteratorStateMachine(typeof(<TargetMethods>d__2))]
[HarmonyTargetMethods]
private static IEnumerable<MethodBase> TargetMethods()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <TargetMethods>d__2(-2);
}
private static bool Prefix(AudioSource __instance, MethodBase __originalMethod)
{
try
{
return ShouldAllowPlayback(__instance, __originalMethod);
}
catch (Exception ex)
{
GuardFailureWarnings.Warn("guard-failure", "Disabled AudioSource guard failed safely and allowed original playback: " + ex.GetType().Name + ".");
return true;
}
}
private static bool ShouldAllowPlayback(AudioSource audioSource, MethodBase originalMethod)
{
if ((Object)(object)audioSource == (Object)null || ((Behaviour)audioSource).isActiveAndEnabled)
{
return true;
}
string methodName = originalMethod?.Name ?? "Play";
string key = $"{((Object)audioSource).GetInstanceID()}|{methodName}";
Warnings.Warn(key, delegate
{
string transformPath = GetTransformPath(((Component)audioSource).transform);
return $"Suppressed disabled AudioSource {methodName} on '{transformPath}' because AudioSource.enabled={((Behaviour)audioSource).enabled}, activeInHierarchy={(Object)(object)((Component)audioSource).gameObject != (Object)null && ((Component)audioSource).gameObject.activeInHierarchy}.";
});
return false;
}
private static bool IsPlaybackMethod(MethodInfo method)
{
return method.ReturnType == typeof(void) && (method.Name == "Play" || method.Name == "PlayDelayed" || method.Name == "PlayScheduled" || method.Name == "PlayOneShot");
}
internal static string GetTransformPath(Transform transform)
{
if ((Object)(object)transform == (Object)null)
{
return "unknown";
}
string text = ((Object)transform).name;
Transform parent = transform.parent;
while ((Object)(object)parent != (Object)null)
{
text = ((Object)parent).name + "/" + text;
parent = parent.parent;
}
return text;
}
}
[HarmonyPatch]
internal static class AudioSourcePlayOneShotNullClipGuardPatch
{
[CompilerGenerated]
private sealed class <TargetMethods>d__2 : IEnumerable<MethodBase>, IEnumerable, IEnumerator<MethodBase>, IEnumerator, IDisposable
{
private int <>1__state;
private MethodBase <>2__current;
private int <>l__initialThreadId;
MethodBase IEnumerator<MethodBase>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <TargetMethods>d__2(int <>1__state)
{
this.<>1__state = <>1__state;
<>l__initialThreadId = Environment.CurrentManagedThreadId;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = AccessTools.Method(typeof(AudioSource), "PlayOneShot", new Type[1] { typeof(AudioClip) }, (Type[])null);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
<>2__current = AccessTools.Method(typeof(AudioSource), "PlayOneShot", new Type[2]
{
typeof(AudioClip),
typeof(float)
}, (Type[])null);
<>1__state = 2;
return true;
case 2:
<>1__state = -1;
return false;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
[DebuggerHidden]
IEnumerator<MethodBase> IEnumerable<MethodBase>.GetEnumerator()
{
if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
{
<>1__state = 0;
return this;
}
return new <TargetMethods>d__2(0);
}
[DebuggerHidden]
IEnumerator IEnumerable.GetEnumerator()
{
return ((IEnumerable<MethodBase>)this).GetEnumerator();
}
}
private static readonly WarningLimiter Warnings = new WarningLimiter();
private static readonly WarningLimiter GuardFailureWarnings = new WarningLimiter();
[IteratorStateMachine(typeof(<TargetMethods>d__2))]
[HarmonyTargetMethods]
private static IEnumerable<MethodBase> TargetMethods()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <TargetMethods>d__2(-2);
}
private static bool Prefix(AudioSource __instance, AudioClip __0)
{
try
{
if ((Object)(object)__0 != (Object)null)
{
return true;
}
WarnNullClip(__instance);
return false;
}
catch (Exception ex)
{
GuardFailureWarnings.Warn("guard-failure", "AudioSource null AudioClip guard failed safely and allowed original PlayOneShot: " + ex.GetType().Name + ".");
return true;
}
}
private static void WarnNullClip(AudioSource audioSource)
{
string key = (((Object)(object)audioSource != (Object)null) ? $"null-clip|{((Object)audioSource).GetInstanceID()}" : "null-clip|unknown");
Warnings.Warn(key, delegate
{
string text = (((Object)(object)audioSource != (Object)null) ? DisabledAudioSourcePlayGuardPatch.GetTransformPath(((Component)audioSource).transform) : "unknown");
return "Suppressed AudioSource.PlayOneShot on '" + text + "' because AudioClip was null.";
});
}
}
[HarmonyPatch(typeof(BushWolfEnemy), "Update")]
internal static class BushWolfEnemyUpdatePatch
{
private static bool Prefix(BushWolfEnemy __instance)
{
if ((Object)(object)__instance == (Object)null || (Object)(object)StartOfRound.Instance == (Object)null)
{
return false;
}
if ((Object)(object)((EnemyAI)__instance).agent == (Object)null || (Object)(object)((EnemyAI)__instance).creatureAnimator == (Object)null || (Object)(object)__instance.animationContainer == (Object)null)
{
return false;
}
return true;
}
private static Exception Finalizer(BushWolfEnemy __instance, Exception __exception)
{
if (__exception is NullReferenceException)
{
try
{
if ((Object)(object)__instance != (Object)null)
{
((EnemyAI)__instance).targetPlayer = null;
((EnemyAI)__instance).movingTowardsTargetPlayer = false;
}
}
catch
{
}
}
return NullRefGuard.Suppress(__exception, "BushWolfEnemy.Update");
}
}
[HarmonyPatch(typeof(BushWolfEnemy), "LateUpdate")]
internal static class BushWolfEnemyLateUpdatePatch
{
private static bool Prefix(BushWolfEnemy __instance)
{
if ((Object)(object)__instance == (Object)null || (Object)(object)StartOfRound.Instance == (Object)null)
{
return false;
}
if ((Object)(object)__instance.tongue == (Object)null || (Object)(object)__instance.tongueStartPoint == (Object)null || (Object)(object)__instance.animationContainer == (Object)null || (Object)(object)__instance.bendHeadBack == (Object)null || __instance.proceduralBodyTargets == null || __instance.IKTargetContainers == null || __instance.IKTargetContainers.Length < __instance.proceduralBodyTargets.Length)
{
return false;
}
return true;
}
private static Exception Finalizer(Exception __exception)
{
return NullRefGuard.Suppress(__exception, "BushWolfEnemy.LateUpdate");
}
}
[HarmonyPatch(typeof(DocileLocustBeesAI), "Update")]
internal static class DocileLocustBeesAIUpdatePatch
{
private static bool Prefix(DocileLocustBeesAI __instance)
{
if ((Object)(object)__instance == (Object)null || (Object)(object)StartOfRound.Instance == (Object)null || (Object)(object)StartOfRound.Instance.activeCamera == (Object)null || (Object)(object)__instance.bugsEffect == (Object)null || (Object)(object)((EnemyAI)__instance).creatureVoice == (Object)null || (Object)(object)__instance.scanNode == (Object)null)
{
return false;
}
if (((EnemyAI)__instance).currentBehaviourStateIndex == 1 && ((Object)(object)((EnemyAI)__instance).creatureSFX == (Object)null || (Object)(object)((EnemyAI)__instance).enemyType == (Object)null || ((EnemyAI)__instance).enemyType.audioClips == null || ((EnemyAI)__instance).enemyType.audioClips.Length == 0 || (Object)(object)RoundManager.Instance == (Object)null))
{
return false;
}
return true;
}
private static Exception Finalizer(Exception __exception)
{
return NullRefGuard.Suppress(__exception, "DocileLocustBeesAI.Update");
}
}
[HarmonyPatch(typeof(CrawlerAI), "Update")]
internal static class CrawlerAIUpdatePatch
{
private static bool Prefix(CrawlerAI __instance)
{
if ((Object)(object)__instance == (Object)null || (Object)(object)StartOfRound.Instance == (Object)null || (Object)(object)GameNetworkManager.Instance == (Object)null || (Object)(object)GameNetworkManager.Instance.localPlayerController == (Object)null)
{
return false;
}
if ((Object)(object)((EnemyAI)__instance).agent == (Object)null || (Object)(object)((EnemyAI)__instance).creatureAnimator == (Object)null || (Object)(object)((Component)__instance).transform == (Object)null || __instance.searchForPlayers == null)
{
return false;
}
return true;
}
private static Exception Finalizer(CrawlerAI __instance, Exception __exception)
{
if (__exception is NullReferenceException && (Object)(object)__instance != (Object)null)
{
try
{
((EnemyAI)__instance).movingTowardsTargetPlayer = false;
}
catch
{
}
}
return NullRefGuard.Suppress(__exception, "CrawlerAI.Update");
}
}
[HarmonyPatch(typeof(EntranceTeleport), "Update")]
internal static class EntranceTeleportUpdatePatch
{
private static readonly FieldInfo TriggerScriptField = AccessTools.Field(typeof(EntranceTeleport), "triggerScript");
private static readonly FieldInfo CheckForEnemiesIntervalField = AccessTools.Field(typeof(EntranceTeleport), "checkForEnemiesInterval");
private static readonly FieldInfo EnemyNearLastCheckField = AccessTools.Field(typeof(EntranceTeleport), "enemyNearLastCheck");
private static readonly FieldInfo GotExitPointField = AccessTools.Field(typeof(EntranceTeleport), "gotExitPoint");
private static bool Prefix(EntranceTeleport __instance)
{
//IL_0054: Unknown result type (might be due to invalid IL or missing references)
//IL_005a: Expected O, but got Unknown
//IL_01de: Unknown result type (might be due to invalid IL or missing references)
//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)__instance == (Object)null)
{
return false;
}
if (!__instance.isEntranceToBuilding)
{
return false;
}
if ((Object)(object)RoundManager.Instance == (Object)null)
{
return false;
}
InteractTrigger val = (InteractTrigger)TriggerScriptField.GetValue(__instance);
if ((Object)(object)val == (Object)null)
{
return false;
}
float num = (float)CheckForEnemiesIntervalField.GetValue(__instance);
if (num > 0f)
{
CheckForEnemiesIntervalField.SetValue(__instance, num - Time.deltaTime);
return false;
}
if (!(bool)GotExitPointField.GetValue(__instance))
{
if (__instance.FindExitPoint())
{
GotExitPointField.SetValue(__instance, true);
}
return false;
}
if (((Object)(object)__instance.exitScript == (Object)null || (Object)(object)__instance.exitScript.entrancePoint == (Object)null) && !__instance.FindExitPoint())
{
return false;
}
CheckForEnemiesIntervalField.SetValue(__instance, 1f);
bool flag = false;
if (RoundManager.Instance.SpawnedEnemies != null)
{
foreach (EnemyAI spawnedEnemy in RoundManager.Instance.SpawnedEnemies)
{
if (!((Object)(object)spawnedEnemy == (Object)null) && !((Object)(object)((Component)spawnedEnemy).transform == (Object)null) && !spawnedEnemy.isEnemyDead)
{
if ((Object)(object)__instance.exitScript == (Object)null || (Object)(object)__instance.exitScript.entrancePoint == (Object)null)
{
break;
}
if (Vector3.Distance(((Component)spawnedEnemy).transform.position, __instance.exitScript.entrancePoint.position) < 7.7f)
{
flag = true;
break;
}
}
}
}
bool flag2 = (bool)EnemyNearLastCheckField.GetValue(__instance);
if (flag && !flag2)
{
EnemyNearLastCheckField.SetValue(__instance, true);
val.hoverTip = "[Near activity detected!]";
}
else if (!flag && flag2)
{
EnemyNearLastCheckField.SetValue(__instance, false);
val.hoverTip = "Enter: [LMB]";
}
return false;
}
private static Exception Finalizer(Exception __exception)
{
return NullRefGuard.Suppress(__exception, "EntranceTeleport.Update");
}
}
[HarmonyPatch(typeof(RoundManager), "FindMainEntrancePosition")]
internal static class RoundManagerFindMainEntrancePositionPatch
{
private const int MaxWarnings = 5;
private static int _warningCount;
private static bool Prefix(bool getTeleportPosition, bool getOutsideEntrance, ref Vector3 __result)
{
//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_0072: Unknown result type (might be due to invalid IL or missing references)
EntranceTeleport[] array = Object.FindObjectsOfType<EntranceTeleport>(false);
EntranceTeleport val = null;
EntranceTeleport val2 = null;
foreach (EntranceTeleport val3 in array)
{
if (!((Object)(object)val3 == (Object)null))
{
if (val == null)
{
val = val3;
}
if (val3.entranceId == 0 && val2 == null)
{
val2 = val3;
}
if (val3.entranceId == 0 && val3.isEntranceToBuilding == getOutsideEntrance)
{
__result = GetEntrancePosition(val3, getTeleportPosition);
return false;
}
}
}
EntranceTeleport val4 = val2 ?? val;
if ((Object)(object)val4 != (Object)null)
{
__result = GetEntrancePosition(val4, getTeleportPosition);
Warn("Main entrance position was missing; using the first available EntranceTeleport instead of origin.");
return false;
}
__result = Vector3.zero;
if (!IsCompanyLevel())
{
Warn("Main entrance position was missing and no EntranceTeleport fallback existed; returning origin.");
}
return false;
}
private static Vector3 GetEntrancePosition(EntranceTeleport entrance, bool getTeleportPosition)
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_005d: Unknown result type (might be due to invalid IL or missing references)
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
//IL_0048: 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)
if ((Object)(object)entrance == (Object)null)
{
return Vector3.zero;
}
if (getTeleportPosition && (Object)(object)entrance.entrancePoint != (Object)null)
{
return entrance.entrancePoint.position;
}
return ((Object)(object)((Component)entrance).transform != (Object)null) ? ((Component)entrance).transform.position : Vector3.zero;
}
private static bool IsCompanyLevel()
{
SelectableLevel val = (((Object)(object)StartOfRound.Instance != (Object)null) ? StartOfRound.Instance.currentLevel : null);
if ((Object)(object)val == (Object)null)
{
return false;
}
return val.levelID == 3 || string.Equals(val.sceneName, "CompanyBuilding", StringComparison.OrdinalIgnoreCase) || (val.PlanetName != null && val.PlanetName.IndexOf("company", StringComparison.OrdinalIgnoreCase) >= 0);
}
private static void Warn(string message)
{
if (_warningCount < 5)
{
_warningCount++;
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogWarning((object)$"{message} ({_warningCount}/{5})");
}
}
}
}
[HarmonyPatch(typeof(HUDManager), "AddChatMessage")]
internal static class HUDManagerAddChatMessagePatch
{
private const int MaxWarnings = 5;
private static int _warningCount;
private static bool Prefix(HUDManager __instance)
{
if (IsHudChatReady(__instance, out var missingDependency))
{
return true;
}
Warn("Skipped HUDManager.AddChatMessage because chat HUD was not ready: " + missingDependency + ".");
return false;
}
private static Exception Finalizer(Exception __exception)
{
if (__exception is NullReferenceException)
{
Warn("Suppressed HUDManager.AddChatMessage NullReferenceException while chat HUD was not ready.");
return null;
}
return __exception;
}
internal static bool IsHudChatReady(HUDManager hudManager, out string missingDependency)
{
if ((Object)(object)hudManager == (Object)null)
{
missingDependency = "HUDManager";
return false;
}
if (hudManager.Chat == null)
{
missingDependency = "HUDManager.Chat";
return false;
}
if ((Object)(object)hudManager.chatText == (Object)null)
{
missingDependency = "HUDManager.chatText";
return false;
}
if (hudManager.ChatMessageHistory == null)
{
missingDependency = "HUDManager.ChatMessageHistory";
return false;
}
if ((Object)(object)GameNetworkManager.Instance == (Object)null)
{
missingDependency = "GameNetworkManager.Instance";
return false;
}
if ((Object)(object)GameNetworkManager.Instance.localPlayerController == (Object)null)
{
missingDependency = "GameNetworkManager.Instance.localPlayerController";
return false;
}
if ((Object)(object)StartOfRound.Instance == (Object)null)
{
missingDependency = "StartOfRound.Instance";
return false;
}
if (StartOfRound.Instance.allPlayerScripts == null || StartOfRound.Instance.allPlayerScripts.Length < 4)
{
missingDependency = "StartOfRound.Instance.allPlayerScripts";
return false;
}
int num = Math.Min(4, StartOfRound.Instance.allPlayerScripts.Length);
for (int i = 0; i < num; i++)
{
if ((Object)(object)StartOfRound.Instance.allPlayerScripts[i] == (Object)null)
{
missingDependency = $"StartOfRound.Instance.allPlayerScripts[{i}]";
return false;
}
}
missingDependency = string.Empty;
return true;
}
internal static void Warn(string message)
{
if (_warningCount < 5)
{
_warningCount++;
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogWarning((object)$"{message} ({_warningCount}/{5})");
}
}
}
}
[HarmonyPatch(typeof(HUDManager), "AddTextMessageClientRpc")]
internal static class HUDManagerAddTextMessageClientRpcPatch
{
private static bool Prefix(HUDManager __instance)
{
if (HUDManagerAddChatMessagePatch.IsHudChatReady(__instance, out var missingDependency))
{
return true;
}
HUDManagerAddChatMessagePatch.Warn("Skipped HUDManager.AddTextMessageClientRpc because chat HUD was not ready: " + missingDependency + ".");
return false;
}
private static Exception Finalizer(Exception __exception)
{
if (__exception is NullReferenceException)
{
HUDManagerAddChatMessagePatch.Warn("Suppressed HUDManager.AddTextMessageClientRpc NullReferenceException while chat HUD was not ready.");
return null;
}
return __exception;
}
}
[HarmonyPatch(typeof(HUDManager), "SyncAllPlayerLevelsServerRpc", new Type[] { })]
internal static class HUDManagerSyncAllPlayerLevelsServerRpcPatch
{
private static readonly WarningLimiter Warnings = new WarningLimiter();
private static bool Prefix(HUDManager __instance)
{
if ((Object)(object)__instance == (Object)null || (Object)(object)((NetworkBehaviour)__instance).NetworkManager == (Object)null || !((NetworkBehaviour)__instance).NetworkManager.IsListening)
{
return false;
}
if ((((NetworkBehaviour)__instance).NetworkManager.IsClient || ((NetworkBehaviour)__instance).NetworkManager.IsHost) && ((NetworkBehaviour)__instance).OwnerClientId != ((NetworkBehaviour)__instance).NetworkManager.LocalClientId)
{
Warnings.Warn("not-owner", "Skipped HUDManager.SyncAllPlayerLevelsServerRpc because the local client does not own HUDManager.");
return false;
}
return true;
}
}
[HarmonyPatch(typeof(InteractTrigger), "UpdateUsedByPlayerClientRpc")]
internal static class InteractTriggerUpdateUsedByPlayerClientRpcPatch
{
private const int MaxWarnings = 5;
private static int _warningCount;
private static bool Prefix(InteractTrigger __instance, int playerNum)
{
if (IsInteractRpcReady(__instance, playerNum, out var missingDependency))
{
return true;
}
Warn($"Skipped InteractTrigger.UpdateUsedByPlayerClientRpc for player {playerNum} because dependencies were not ready: {missingDependency}.");
return false;
}
private static Exception Finalizer(Exception __exception)
{
if (__exception is NullReferenceException)
{
Warn("Suppressed InteractTrigger.UpdateUsedByPlayerClientRpc NullReferenceException while trigger dependencies were not ready.");
return null;
}
return __exception;
}
private static bool IsInteractRpcReady(InteractTrigger trigger, int playerNum, out string missingDependency)
{
if ((Object)(object)trigger == (Object)null)
{
missingDependency = "InteractTrigger";
return false;
}
if (trigger.onInteractEarlyOtherClients == null)
{
missingDependency = GetTriggerName(trigger) + ".onInteractEarlyOtherClients";
return false;
}
if (!TryGetPlayer(playerNum, out var player, out missingDependency))
{
return false;
}
if ((Object)(object)GameNetworkManager.Instance == (Object)null)
{
missingDependency = "GameNetworkManager.Instance";
return false;
}
PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
if ((Object)(object)localPlayerController == (Object)null || (Object)(object)((Component)localPlayerController).transform == (Object)null)
{
missingDependency = "GameNetworkManager.Instance.localPlayerController";
return false;
}
if (trigger.specialCharacterAnimation && trigger.setVehicleAnimation && (Object)(object)player.gameplayCamera == (Object)null)
{
missingDependency = $"player {playerNum} gameplayCamera";
return false;
}
missingDependency = string.Empty;
return true;
}
private static bool TryGetPlayer(int playerNum, out PlayerControllerB player, out string missingDependency)
{
player = null;
if ((Object)(object)StartOfRound.Instance == (Object)null || StartOfRound.Instance.allPlayerScripts == null || playerNum < 0 || playerNum >= StartOfRound.Instance.allPlayerScripts.Length)
{
missingDependency = "StartOfRound.Instance.allPlayerScripts";
return false;
}
player = StartOfRound.Instance.allPlayerScripts[playerNum];
if ((Object)(object)player == (Object)null || (Object)(object)((Component)player).transform == (Object)null)
{
missingDependency = $"StartOfRound.Instance.allPlayerScripts[{playerNum}]";
return false;
}
missingDependency = string.Empty;
return true;
}
private static string GetTriggerName(InteractTrigger trigger)
{
return ((Object)(object)trigger != (Object)null && (Object)(object)((Component)trigger).gameObject != (Object)null) ? ((Object)((Component)trigger).gameObject).name : "unknown trigger";
}
private static void Warn(string message)
{
if (_warningCount < 5)
{
_warningCount++;
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogWarning((object)$"{message} ({_warningCount}/{5})");
}
}
}
}
[HarmonyPatch(typeof(RadMechAI), "SetExplosion")]
internal static class RadMechAISetExplosionPatch
{
private static readonly WarningLimiter Warnings = new WarningLimiter();
private static Exception Finalizer(Exception __exception)
{
return SuppressKnownException(__exception, "RadMechAI.SetExplosion", Warnings);
}
internal static Exception SuppressKnownException(Exception exception, string key, WarningLimiter warnings)
{
if (exception is NullReferenceException)
{
warnings.Warn(key, "Suppressed " + key + " NullReferenceException.");
return null;
}
return exception;
}
}
[HarmonyPatch(typeof(RadMechAI), "SetExplosionClientRpc")]
internal static class RadMechAISetExplosionClientRpcPatch
{
private static readonly WarningLimiter Warnings = new WarningLimiter();
private static Exception Finalizer(Exception __exception)
{
return RadMechAISetExplosionPatch.SuppressKnownException(__exception, "RadMechAI.SetExplosionClientRpc", Warnings);
}
}
[HarmonyPatch(typeof(JetpackItem), "DeactivateJetpack")]
internal static class JetpackItemDeactivateJetpackPatch
{
private static readonly WarningLimiter Warnings = new WarningLimiter();
private static Exception Finalizer(Exception __exception)
{
return RadMechAISetExplosionPatch.SuppressKnownException(__exception, "JetpackItem.DeactivateJetpack", Warnings);
}
}
[HarmonyPatch(typeof(JetpackItem), "ItemActivate")]
internal static class JetpackItemItemActivatePatch
{
private static readonly WarningLimiter Warnings = new WarningLimiter();
private static Exception Finalizer(Exception __exception)
{
return RadMechAISetExplosionPatch.SuppressKnownException(__exception, "JetpackItem.ItemActivate", Warnings);
}
}
[HarmonyPatch(typeof(GrabbableObject), "ActivateItemRpc")]
internal static class GrabbableObjectActivateItemRpcPatch
{
private static readonly WarningLimiter Warnings = new WarningLimiter();
private static Exception Finalizer(GrabbableObject __instance, Exception __exception)
{
if (!(__instance is JetpackItem))
{
return __exception;
}
return RadMechAISetExplosionPatch.SuppressKnownException(__exception, "GrabbableObject.ActivateItemRpc", Warnings);
}
}
[HarmonyPatch(typeof(LobbySlot), "SetModdedIcon")]
internal static class LobbySlotSetModdedIconPatch
{
private static readonly WarningLimiter Warnings = new WarningLimiter();
private static bool Prefix(LobbySlot __instance, ModdedState moddedState)
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: Invalid comparison between Unknown and I4
if ((Object)(object)__instance == (Object)null)
{
Warnings.Warn("null-slot", "Skipped LobbySlot.SetModdedIcon because the lobby slot was null.");
return false;
}
if ((int)moddedState == 0 && (Object)(object)__instance.modStateUnknownIcon == (Object)null)
{
Warnings.Warn("missing-unknown-icon", "Skipped LobbySlot.SetModdedIcon because modStateUnknownIcon was missing.");
return false;
}
if ((int)moddedState == 2 && (Object)(object)__instance.modStateTrueIcon == (Object)null)
{
Warnings.Warn("missing-modded-icon", "Skipped LobbySlot.SetModdedIcon because modStateTrueIcon was missing.");
return false;
}
return true;
}
private static Exception Finalizer(Exception __exception)
{
if (__exception is NullReferenceException)
{
Warnings.Warn("finalizer-null-reference", "Suppressed LobbySlot.SetModdedIcon NullReferenceException.");
return null;
}
return __exception;
}
}
[HarmonyPatch(typeof(DisplayPlayerMicVolume), "InitMic")]
internal static class DisplayPlayerMicVolumeInitMicPatch
{
private static readonly WarningLimiter Warnings = new WarningLimiter();
private static bool Prefix(DisplayPlayerMicVolume __instance)
{
if ((Object)(object)__instance == (Object)null || (Object)(object)IngamePlayerSettings.Instance == (Object)null || IngamePlayerSettings.Instance.unsavedSettings == null)
{
return false;
}
IngamePlayerSettings.Instance.RefreshAndDisplayCurrentMicrophone(false);
string micDevice = IngamePlayerSettings.Instance.unsavedSettings.micDevice;
if (!IsValidMicrophoneDevice(micDevice))
{
return false;
}
Traverse val = Traverse.Create((object)__instance);
string value = val.Field("_device").GetValue<string>();
if (IsValidMicrophoneDevice(value) && Microphone.IsRecording(value))
{
Microphone.End(value);
}
try
{
int num = default(int);
int num2 = default(int);
Microphone.GetDeviceCaps(micDevice, ref num, ref num2);
int num3 = ((num2 <= 0) ? 44100 : Mathf.Clamp(44100, Mathf.Max(num, 1), num2));
val.Field("_device").SetValue((object)micDevice);
val.Field("_clipRecord").SetValue((object)Microphone.Start(micDevice, true, 1, num3));
}
catch (Exception ex) when (ex is ArgumentException || ex is InvalidOperationException)
{
Warn("Skipping microphone preview for unavailable device '" + micDevice + "': " + ex.Message);
val.Field("_clipRecord").SetValue((object)null);
}
return false;
}
internal static void Warn(string message)
{
Warnings.Warn("DisplayPlayerMicVolume", message);
}
internal static bool IsValidMicrophoneDevice(string device)
{
if (string.IsNullOrWhiteSpace(device) || device == "none" || device == "LCNoMic" || Microphone.devices == null)
{
return false;
}
return Array.IndexOf(Microphone.devices, device) >= 0;
}
}
[HarmonyPatch(typeof(DisplayPlayerMicVolume), "StopMicrophone")]
internal static class DisplayPlayerMicVolumeStopMicrophonePatch
{
private static bool Prefix(DisplayPlayerMicVolume __instance)
{
if ((Object)(object)__instance == (Object)null)
{
return false;
}
try
{
string value = Traverse.Create((object)__instance).Field("_device").GetValue<string>();
if (DisplayPlayerMicVolumeInitMicPatch.IsValidMicrophoneDevice(value) && Microphone.IsRecording(value))
{
Microphone.End(value);
}
}
catch (Exception ex)
{
DisplayPlayerMicVolumeInitMicPatch.Warn("Skipping microphone stop because it failed safely: " + ex.GetType().Name);
}
return false;
}
}
[HarmonyPatch(typeof(DisplayPlayerMicVolume), "LevelMax")]
internal static class DisplayPlayerMicVolumeLevelMaxPatch
{
private static bool Prefix(DisplayPlayerMicVolume __instance, ref float __result)
{
__result = 0f;
if ((Object)(object)__instance == (Object)null || (Object)(object)IngamePlayerSettings.Instance == (Object)null || IngamePlayerSettings.Instance.unsavedSettings == null)
{
return false;
}
string micDevice = IngamePlayerSettings.Instance.unsavedSettings.micDevice;
if (!DisplayPlayerMicVolumeInitMicPatch.IsValidMicrophoneDevice(micDevice) || !Microphone.IsRecording(micDevice))
{
return false;
}
try
{
AudioClip value = Traverse.Create((object)__instance).Field("_clipRecord").GetValue<AudioClip>();
return (Object)(object)value != (Object)null;
}
catch (Exception ex)
{
DisplayPlayerMicVolumeInitMicPatch.Warn("Skipping microphone level preview because it failed safely: " + ex.GetType().Name);
return false;
}
}
}
[HarmonyPatch(typeof(NavMeshSurface), "CollectSources")]
internal static class NavMeshSurfaceCollectSourcesPatch
{
private static readonly WarningLimiter Warnings = new WarningLimiter();
private static readonly WarningLimiter GuardFailureWarnings = new WarningLimiter();
private static void Postfix(NavMeshSurface __instance, ref List<NavMeshBuildSource> __result)
{
try
{
FilterUnreadableMeshSources(__instance, __result);
}
catch (Exception ex)
{
GuardFailureWarnings.Warn("guard-failure", "NavMeshSurface source filter failed safely and left sources unchanged: " + ex.GetType().Name + ".");
}
}
private static void FilterUnreadableMeshSources(NavMeshSurface surface, List<NavMeshBuildSource> sources)
{
//IL_0048: 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)
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
if (sources == null || sources.Count == 0)
{
return;
}
int num = 0;
string surfaceName = GetSurfaceName(surface);
bool flag = ShouldLog(surfaceName);
HashSet<string> hashSet = (flag ? new HashSet<string>() : null);
for (int num2 = sources.Count - 1; num2 >= 0; num2--)
{
NavMeshBuildSource source = sources[num2];
if (TryGetUnreadableMesh(source, out var mesh))
{
sources.RemoveAt(num2);
num++;
hashSet?.Add(GetMeshName(mesh));
}
}
if (num > 0 && flag)
{
Warn(surfaceName, hashSet, num);
}
}
private static bool TryGetUnreadableMesh(NavMeshBuildSource source, out Mesh mesh)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
mesh = null;
if ((int)((NavMeshBuildSource)(ref source)).shape == 0)
{
Object sourceObject = ((NavMeshBuildSource)(ref source)).sourceObject;
Mesh val = (Mesh)(object)((sourceObject is Mesh) ? sourceObject : null);
if (val != null && !((Object)(object)val == (Object)null))
{
mesh = val;
return !val.isReadable;
}
}
return false;
}
private static bool ShouldLog(string surfaceName)
{
string key = "unreadable-navmesh-sources|" + surfaceName;
return Warnings.CanWarn(key);
}
private static void Warn(string surfaceName, HashSet<string> meshNames, int removedCount)
{
string key = "unreadable-navmesh-sources|" + surfaceName;
Warnings.Warn(key, delegate
{
string arg = ((meshNames != null && meshNames.Count > 0) ? string.Join(", ", meshNames) : "unknown");
return $"Filtered {removedCount} unreadable mesh source(s) from NavMeshSurface '{surfaceName}' before runtime NavMesh build: {arg}.";
});
}
private static string GetSurfaceName(NavMeshSurface surface)
{
return ((Object)(object)surface != (Object)null && (Object)(object)((Component)surface).gameObject != (Object)null) ? ((Object)((Component)surface).gameObject).name : "unknown";
}
private static string GetMeshName(Mesh mesh)
{
return ((Object)(object)mesh != (Object)null && !string.IsNullOrEmpty(((Object)mesh).name)) ? ((Object)mesh).name : "unnamed mesh";
}
}
[HarmonyPatch(typeof(EnemyAI), "DoAIInterval")]
internal static class EnemyAINavMeshGuardPatch
{
private const float RecoveryAttemptCooldown = 0.5f;
private const float RecoveryCacheCleanupInterval = 30f;
private static readonly float[] SampleRadii = new float[5] { 2f, 4f, 8f, 16f, 32f };
private static readonly WarningLimiter Warnings = new WarningLimiter();
private static readonly Dictionary<int, float> NextRecoveryAttemptTimes = new Dictionary<int, float>();
private static float _nextRecoveryCacheCleanupTime;
private static bool Prefix(EnemyAI __instance)
{
try
{
return GuardEnemyAIInterval(__instance);
}
catch (Exception ex)
{
string enemyName = GetEnemyName(__instance);
Warn(enemyName, "NavMesh guard failed safely for " + enemyName + ": " + ex.GetType().Name + ".");
return true;
}
}
private static bool GuardEnemyAIInterval(EnemyAI enemy)
{
if ((Object)(object)enemy == (Object)null || enemy.inSpecialAnimation || (Object)(object)enemy.agent == (Object)null || !enemy.moveTowardsDestination || !((Behaviour)enemy.agent).enabled || enemy.agent.isOnNavMesh)
{
return true;
}
string enemyName = GetEnemyName(enemy);
if (!CanAttemptRecovery(enemy))
{
return false;
}
if (!((NetworkBehaviour)enemy).IsOwner)
{
Warn(enemyName, "Suppressed non-owner " + enemyName + " SetDestination while its NavMeshAgent is off the NavMesh.");
return false;
}
if (enemy.isEnemyDead)
{
enemy.moveTowardsDestination = false;
TrySyncPositionToClients(enemy);
Warn(enemyName, "Suppressed " + enemyName + " SetDestination while it is dead and its NavMeshAgent is off the NavMesh.");
return false;
}
if (TryWarpToNearbyNavMesh(enemy))
{
Warn(enemyName, "Recovered " + enemyName + " NavMeshAgent by warping it back onto the NavMesh.");
return true;
}
enemy.moveTowardsDestination = false;
TrySyncPositionToClients(enemy);
Warn(enemyName, "Suppressed " + enemyName + " SetDestination while its NavMeshAgent is off the NavMesh and no nearby NavMesh point was found.");
return false;
}
private static bool TryWarpToNearbyNavMesh(EnemyAI enemy)
{
//IL_0013: 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)
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
int areaMask = enemy.agent.areaMask;
Vector3 position = ((Component)enemy).transform.position;
if (TryWarpToNearbyNavMesh(enemy, position, areaMask))
{
return true;
}
return areaMask != -1 && TryWarpToNearbyNavMesh(enemy, position, -1);
}
private static bool TryWarpToNearbyNavMesh(EnemyAI enemy, Vector3 position, int areaMask)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
NavMeshHit val = default(NavMeshHit);
for (int i = 0; i < SampleRadii.Length; i++)
{
if (NavMesh.SamplePosition(position, ref val, SampleRadii[i], areaMask) && IsUsableRecoveryPoint(enemy, ((NavMeshHit)(ref val)).position, areaMask) && enemy.agent.Warp(((NavMeshHit)(ref val)).position))
{
if (enemy.agent.isOnNavMesh)
{
enemy.agent.ResetPath();
}
return true;
}
}
return false;
}
private static bool IsUsableRecoveryPoint(EnemyAI enemy, Vector3 position, int areaMask)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Expected O, but got Unknown
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
//IL_004f: Invalid comparison between Unknown and I4
if (enemy.destination == Vector3.zero)
{
return true;
}
NavMeshPath val = enemy.path1;
if (val == null)
{
val = (enemy.path1 = new NavMeshPath());
}
return NavMesh.CalculatePath(position, enemy.destination, areaMask, val) && (int)val.status != 2;
}
private static bool CanAttemptRecovery(EnemyAI enemy)
{
int instanceID = ((Object)enemy).GetInstanceID();
float realtimeSinceStartup = Time.realtimeSinceStartup;
CleanupRecoveryCacheIfNeeded(realtimeSinceStartup);
if (NextRecoveryAttemptTimes.TryGetValue(instanceID, out var value) && realtimeSinceStartup < value)
{
return false;
}
NextRecoveryAttemptTimes[instanceID] = realtimeSinceStartup + 0.5f;
return true;
}
private static void Warn(string enemyName, string message)
{
Warnings.Warn(enemyName, message);
}
private static void CleanupRecoveryCacheIfNeeded(float now)
{
if (now < _nextRecoveryCacheCleanupTime || NextRecoveryAttemptTimes.Count < 128)
{
return;
}
_nextRecoveryCacheCleanupTime = now + 30f;
List<int> list = null;
foreach (KeyValuePair<int, float> nextRecoveryAttemptTime in NextRecoveryAttemptTimes)
{
if (!(nextRecoveryAttemptTime.Value >= now))
{
if (list == null)
{
list = new List<int>();
}
list.Add(nextRecoveryAttemptTime.Key);
}
}
if (list != null)
{
for (int i = 0; i < list.Count; i++)
{
NextRecoveryAttemptTimes.Remove(list[i]);
}
}
}
private static string GetEnemyName(EnemyAI enemy)
{
if ((Object)(object)enemy == (Object)null)
{
return "Unknown Enemy";
}
if ((Object)(object)enemy.enemyType != (Object)null && !string.IsNullOrEmpty(enemy.enemyType.enemyName))
{
return enemy.enemyType.enemyName;
}
return ((Object)enemy).name;
}
private static void TrySyncPositionToClients(EnemyAI enemy)
{
try
{
enemy.SyncPositionToClients();
}
catch (Exception ex)
{
Warn(GetEnemyName(enemy), "Skipped EnemyAI position sync after NavMesh guard because it failed safely: " + ex.GetType().Name + ".");
}
}
}
[HarmonyPatch]
internal static class NetworkObjectDestroyGuardPatch
{
[CompilerGenerated]
private sealed class <TargetMethods>d__4 : IEnumerable<MethodBase>, IEnumerable, IEnumerator<MethodBase>, IEnumerator, IDisposable
{
private int <>1__state;
private MethodBase <>2__current;
private int <>l__initialThreadId;
MethodBase IEnumerator<MethodBase>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <TargetMethods>d__4(int <>1__state)
{
this.<>1__state = <>1__state;
<>l__initialThreadId = Environment.CurrentManagedThreadId;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = AccessTools.Method(typeof(Object), "Destroy", new Type[1] { typeof(Object) }, (Type[])null);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
<>2__current = AccessTools.Method(typeof(Object), "Destroy", new Type[2]
{
typeof(Object),
typeof(float)
}, (Type[])null);
<>1__state = 2;
return true;
case 2:
<>1__state = -1;
return false;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
[DebuggerHidden]
IEnumerator<MethodBase> IEnumerable<MethodBase>.GetEnumerator()
{
if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
{
<>1__state = 0;
return this;
}
return new <TargetMethods>d__4(0);
}
[DebuggerHidden]
IEnumerator IEnumerable.GetEnumerator()
{
return ((IEnumerable<MethodBase>)this).GetEnumerator();
}
}
private const float WarningInterval = 5f;
private static readonly Dictionary<ulong, float> LastWarningTimes = new Dictionary<ulong, float>();
private static readonly WarningLimiter Warnings = new WarningLimiter();
private static readonly WarningLimiter GuardFailureWarnings = new WarningLimiter();
[IteratorStateMachine(typeof(<TargetMethods>d__4))]
[HarmonyTargetMethods]
private static IEnumerable<MethodBase> TargetMethods()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <TargetMethods>d__4(-2);
}
private static bool Prefix(Object obj)
{
try
{
return ShouldAllowDestroy(obj);
}
catch (Exception ex)
{
GuardFailureWarnings.Warn("guard-failure", "NetworkObject destroy guard failed safely and allowed original Destroy: " + ex.GetType().Name + ".");
return true;
}
}
private static bool ShouldAllowDestroy(Object obj)
{
if (obj == (Object)null || (Object)(object)NetworkManager.Singleton == (Object)null || NetworkManager.Singleton.IsServer)
{
return true;
}
bool flag = obj is GameObject;
GameObject val = (GameObject)(object)((obj is GameObject) ? obj : null);
if ((Object)(object)val == (Object)null)
{
Component val2 = (Component)(object)((obj is Component) ? obj : null);
if (val2 != null)
{
val = val2.gameObject;
}
}
if ((Object)(object)val == (Object)null)
{
return true;
}
RagdollGrabbableObject val3 = val.GetComponent<RagdollGrabbableObject>() ?? val.GetComponentInParent<RagdollGrabbableObject>();
if ((Object)(object)val3 == (Object)null && flag)
{
val3 = val.GetComponentInChildren<RagdollGrabbableObject>();
}
if ((Object)(object)val3 == (Object)null)
{
return true;
}
NetworkObject component = ((Component)val3).GetComponent<NetworkObject>();
if ((Object)(object)component == (Object)null || !component.IsSpawned)
{
return true;
}
WarnBlockedDestroy(component);
return false;
}
private static void WarnBlockedDestroy(NetworkObject networkObject)
{
float realtimeSinceStartup = Time.realtimeSinceStartup;
if (!LastWarningTimes.TryGetValue(networkObject.NetworkObjectId, out var value) || !(realtimeSinceStartup - value < 5f))
{
LastWarningTimes[networkObject.NetworkObjectId] = realtimeSinceStartup;
Warnings.Warn($"blocked-destroy|{networkObject.NetworkObjectId}", "Blocked client-side Destroy on spawned " + ((Object)networkObject).name + "; waiting for server despawn.");
}
}
}
[HarmonyPatch]
internal static class NetworkObjectParentChangedPatch
{
private static readonly WarningLimiter Warnings = new WarningLimiter();
[HarmonyPrepare]
private static bool Prepare()
{
return TargetMethod() != null;
}
[HarmonyTargetMethod]
private static MethodBase TargetMethod()
{
return AccessTools.Method(typeof(NetworkObject), "OnTransformParentChanged", (Type[])null, (Type[])null);
}
private static bool Prefix(NetworkObject __instance)
{
if ((Object)(object)__instance == (Object)null || __instance.IsSpawned)
{
return true;
}
Warnings.Warn(GetWarningKey(__instance), () => "Skipped NetworkObject.OnTransformParentChanged for unspawned object '" + GetObjectName(__instance) + "' to avoid invalid reparent handling.");
return false;
}
private static Exception Finalizer(NetworkObject __instance, Exception __exception)
{
if (IsKnownSpawnStateException(__exception))
{
Warnings.Warn(GetWarningKey(__instance), () => "Suppressed NetworkObject reparent SpawnStateException for '" + GetObjectName(__instance) + "'.");
return null;
}
return __exception;
}
private static bool IsKnownSpawnStateException(Exception exception)
{
return exception != null && exception.GetType().Name == "SpawnStateException" && exception.Message != null && exception.Message.Contains("NetworkObject can only be reparented after being spawned");
}
private static string GetWarningKey(NetworkObject networkObject)
{
return ((Object)(object)networkObject != (Object)null) ? $"network-parent|{((Object)networkObject).GetInstanceID()}" : "network-parent|unknown";
}
private static string GetObjectName(NetworkObject networkObject)
{
return ((Object)(object)networkObject != (Object)null) ? ((Object)networkObject).name : "unknown";
}
}
[HarmonyPatch]
internal static class EnemyHealthBarsLateUpdatePatch
{
private static readonly WarningLimiter Warnings = new WarningLimiter();
[HarmonyPrepare]
private static bool Prepare()
{
return TargetMethod() != null;
}
[HarmonyTargetMethod]
private static MethodBase TargetMethod()
{
Type type = AccessTools.TypeByName("EnemyHealthBars.Scripts.HealthBar");
return OptionalPatchTargetResolver.FindMethod(type, "LateUpdate", false, typeof(void));
}
private static Exception Finalizer(Exception __exception)
{
if (__exception is NullReferenceException)
{
Warnings.Warn("EnemyHealthBars.HealthBar.LateUpdate", "Suppressed EnemyHealthBars.HealthBar.LateUpdate NullReferenceException.");
return null;
}
return __exception;
}
}
[HarmonyPatch]
internal static class ShipLootPlusUiHelperPatch
{
[CompilerGenerated]
private sealed class <TargetMethods>d__2 : IEnumerable<MethodBase>, IEnumerable, IEnumerator<MethodBase>, IEnumerator, IDisposable
{
private int <>1__state;
private MethodBase <>2__current;
private int <>l__initialThreadId;
private Type <uiHelperType>5__1;
private HashSet<MethodBase> <yieldedMethods>5__2;
private MethodBase <calculateLootValue>5__3;
private MethodBase <refreshElementValues>5__4;
private Type[] <>s__5;
private int <>s__6;
private Type <nestedType>5__7;
private MethodInfo[] <>s__8;
private int <>s__9;
private MethodInfo <method>5__10;
MethodBase IEnumerator<MethodBase>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <TargetMethods>d__2(int <>1__state)
{
this.<>1__state = <>1__state;
<>l__initialThreadId = Environment.CurrentManagedThreadId;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<uiHelperType>5__1 = null;
<yieldedMethods>5__2 = null;
<calculateLootValue>5__3 = null;
<refreshElementValues>5__4 = null;
<>s__5 = null;
<nestedType>5__7 = null;
<>s__8 = null;
<method>5__10 = null;
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<uiHelperType>5__1 = AccessTools.TypeByName("ShipLootPlus.Utils.UiHelper");
if (<uiHelperType>5__1 == null)
{
return false;
}
<yieldedMethods>5__2 = new HashSet<MethodBase>();
<calculateLootValue>5__3 = OptionalPatchTargetResolver.FindMethod(<uiHelperType>5__1, "CalculateLootValue", true, null, typeof(List<GrabbableObject>), typeof(string));
if (<calculateLootValue>5__3 != null && <yieldedMethods>5__2.Add(<calculateLootValue>5__3))
{
<>2__current = <calculateLootValue>5__3;
<>1__state = 1;
return true;
}
goto IL_00e4;
case 1:
<>1__state = -1;
goto IL_00e4;
case 2:
<>1__state = -1;
goto IL_014e;
case 3:
{
<>1__state = -1;
<method>5__10 = null;
goto IL_020a;
}
IL_0218:
if (<>s__9 < <>s__8.Length)
{
<method>5__10 = <>s__8[<>s__9];
if (!ShouldPatchGeneratedMethod(<nestedType>5__7, <method>5__10) || !<yieldedMethods>5__2.Add(<method>5__10))
{
goto IL_020a;
}
<>2__current = <method>5__10;
<>1__state = 3;
return true;
}
<>s__8 = null;
<nestedType>5__7 = null;
<>s__6++;
goto IL_0248;
IL_014e:
<>s__5 = <uiHelperType>5__1.GetNestedTypes(BindingFlags.Public | BindingFlags.NonPublic);
<>s__6 = 0;
goto IL_0248;
IL_0248:
if (<>s__6 < <>s__5.Length)
{
<nestedType>5__7 = <>s__5[<>s__6];
<>s__8 = <nestedType>5__7.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
<>s__9 = 0;
goto IL_0218;
}
<>s__5 = null;
return false;
IL_020a:
<>s__9++;
goto IL_0218;
IL_00e4:
<refreshElementValues>5__4 = OptionalPatchTargetResolver.FindMethod(<uiHelperType>5__1, "RefreshElementValues", true, typeof(void));
if (<refreshElementValues>5__4 != null && <yieldedMethods>5__2.Add(<refreshElementValues>5__4))
{
<>2__current = <refreshElementValues>5__4;
<>1__state = 2;
return true;
}
goto IL_014e;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
[DebuggerHidden]
IEnumerator<MethodBase> IEnumerable<MethodBase>.GetEnumerator()
{
if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
{
<>1__state = 0;
return this;
}
return new <TargetMethods>d__2(0);
}
[DebuggerHidden]
IEnumerator IEnumerable.GetEnumerator()
{
return ((IEnumerable<MethodBase>)this).GetEnumerator();
}
}
private static readonly WarningLimiter Warnings = new WarningLimiter();
[HarmonyPrepare]
private static bool Prepare()
{
return AccessTools.TypeByName("ShipLootPlus.Utils.UiHelper") != null;
}
[IteratorStateMachine(typeof(<TargetMethods>d__2))]
[HarmonyTargetMethods]
private static IEnumerable<MethodBase> TargetMethods()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <TargetMethods>d__2(-2);
}
private static Exception Finalizer(MethodBase __originalMethod, Exception __exception)
{
if (__exception is NullReferenceException)
{
string text = ((__originalMethod != null) ? __originalMethod.Name : "unknown");
Warnings.Warn("ShipLootPlus.UiHelper." + text, "Compatibility guard handled ShipLootPlus.UiHelper." + text + " NullReferenceException while refreshing loot UI.");
return null;
}
return __exception;
}
private static bool ShouldPatchGeneratedMethod(Type nestedType, MethodInfo method)
{
if (nestedType == null || method == null)
{
return false;
}
return method.ReturnType == typeof(bool) && (method.Name.Contains("<CalculateLootValue>") || (method.Name == "MoveNext" && nestedType.Name.Contains("<UpdateDatapoints>")));
}
}
[HarmonyPatch]
internal static class NightVisionInsideLightingPostfixPatch
{
private static readonly WarningLimiter Warnings = new WarningLimiter();
[HarmonyPrepare]
private static bool Prepare()
{
return TargetMethod() != null;
}
[HarmonyTargetMethod]
private static MethodBase TargetMethod()
{
Type type = AccessTools.TypeByName("NightVision.Patches.NightVisionOutdoors");
return OptionalPatchTargetResolver.FindMethod(type, "InsideLightingPostfix", true, typeof(void), typeof(TimeOfDay));
}
private static Exception Finalizer(Exception __exception)
{
if (__exception is NullReferenceException)
{
Warnings.Warn("NightVision.InsideLightingPostfix", "Compatibility guard handled NightVision outdoors lighting NullReferenceException while inside lighting changed.");
return null;
}
return __exception;
}
}
[HarmonyPatch]
internal static class ChatCommandApiStartHostPostfixPatch
{
private static readonly WarningLimiter Warnings = new WarningLimiter();
[HarmonyPrepare]
private static bool Prepare()
{
return TargetMethod() != null;
}
[HarmonyTargetMethod]
private static MethodBase TargetMethod()
{
Type type = AccessTools.TypeByName("ChatCommandAPI.Patches.GameNetworkManager_StartHost");
return OptionalPatchTargetResolver.FindMethod(type, "Postfix", true, typeof(void));
}
private static Exception Finalizer(Exception __exception)
{
if (__exception is NullReferenceException)
{
Warnings.Warn("ChatCommandAPI.GameNetworkManager_StartHost.Postfix", "Compatibility guard handled ChatCommandAPI StartHost Postfix NullReferenceException while hosting a lobby.");
return null;
}
return __exception;
}
}
internal static class OptionalPatchTargetResolver
{
internal static MethodBase FindMethod(Type type, string methodName, bool isStatic, Type returnType, params Type[] parameterTypes)
{
if (type == null)
{
return null;
}
MethodInfo methodInfo = AccessTools.Method(type, methodName, parameterTypes, (Type[])null);
if (methodInfo == null || methodInfo.IsStatic != isStatic || (returnType != null && methodInfo.ReturnType != returnType))
{
return null;
}
return methodInfo;
}
}
[HarmonyPatch(typeof(PlayerControllerB), "NearOtherPlayers")]
internal static class PlayerControllerBNearOtherPlayersPatch
{
private static bool Prefix(PlayerControllerB __instance, float checkRadius, ref bool __result)
{
try
{
return CheckNearOtherPlayersSafely(__instance, checkRadius, ref __result);
}
catch (Exception exception)
{
__result = false;
return NullRefGuard.Suppress(exception, "PlayerControllerB.NearOtherPlayers") != null;
}
}
private static bool CheckNearOtherPlayersSafely(PlayerControllerB __instance, float checkRadius, ref bool __result)
{
//IL_009c: Unknown result type (might be due to invalid IL or missing references)
//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)__instance == (Object)null || (Object)(object)((Component)__instance).transform == (Object)null || (Object)(object)StartOfRound.Instance == (Object)null || StartOfRound.Instance.allPlayerScripts == null)
{
__result = false;
return false;
}
float num = checkRadius * checkRadius;
PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
foreach (PlayerControllerB val in allPlayerScripts)
{
if (!((Object)(object)val == (Object)null) && !((Object)(object)val == (Object)(object)__instance) && val.isPlayerControlled && !((Object)(object)((Component)val).transform == (Object)null))
{
Vector3 val2 = ((Component)__instance).transform.position - ((Component)val).transform.position;
if (((Vector3)(ref val2)).sqrMagnitude < num)
{
__result = true;
return false;
}
}
}
__result = false;
return false;
}
}
[HarmonyPatch(typeof(PlayerControllerB), "PlayJumpAudio")]
internal static class PlayerControllerBPlayJumpAudioPatch
{
private const int MaxWarnings = 5;
private static int _warningCount;
private static bool Prefix(PlayerControllerB __instance)
{
try
{
PlayJumpAudioSafely(__instance);
}
catch (Exception ex)
{
Warn("Skipped PlayerControllerB.PlayJumpAudio because the guard failed safely: " + ex.GetType().Name + ".");
}
return false;
}
private static void PlayJumpAudioSafely(PlayerControllerB player)
{
if ((Object)(object)player == (Object)null || (Object)(object)player.movementAudio == (Object)null || (Object)(object)StartOfRound.Instance == (Object)null)
{
Warn("Skipped PlayerControllerB.PlayJumpAudio because audio dependencies were not ready.");
return;
}
string missingDependency;
AudioClip val = TryGetSuitJumpAudio(player, out missingDependency) ?? TryGetDefaultJumpAudio(ref missingDependency);
if ((Object)(object)val == (Object)null)
{
Warn("Skipped PlayerControllerB.PlayJumpAudio because no jump audio clip was available: " + missingDependency + ".");
return;
}
if (!string.IsNullOrEmpty(missingDependency))
{
Warn("Used default jump audio because suit jump audio was not available: " + missingDependency + ".");
}
player.movementAudio.PlayOneShot(val);
}
private static Exception Finalizer(Exception __exception)
{
if (__exception is ArgumentOutOfRangeException || __exception is NullReferenceException)
{
Warn("Suppressed PlayerControllerB.PlayJumpAudio " + __exception.GetType().Name + ".");
return null;
}
return __exception;
}
private static AudioClip TryGetSuitJumpAudio(PlayerControllerB player, out string missingDependency)
{
missingDependency = string.Empty;
if ((Object)(object)StartOfRound.Instance.unlockablesList == (Object)null || StartOfRound.Instance.unlockablesList.unlockables == null)
{
missingDependency = "StartOfRound.Instance.unlockablesList";
return null;
}
if (player.currentSuitID < 0 || player.currentSuitID >= StartOfRound.Instance.unlockablesList.unlockables.Count)
{
missingDependency = $"currentSuitID {player.currentSuitID} outside unlockables count {StartOfRound.Instance.unlockablesList.unlockables.Count}";
return null;
}
UnlockableItem val = StartOfRound.Instance.unlockablesList.unlockables[player.currentSuitID];
if (val == null)
{
missingDependency = $"unlockables[{player.currentSuitID}]";
return null;
}
AudioClip jumpAudio = val.jumpAudio;
if ((Object)(object)jumpAudio == (Object)null)
{
missingDependency = $"unlockables[{player.currentSuitID}].jumpAudio";
}
return jumpAudio;
}
private static AudioClip TryGetDefaultJumpAudio(ref string missingDependency)
{
if ((Object)(object)StartOfRound.Instance == (Object)null || (Object)(object)StartOfRound.Instance.playerJumpSFX == (Object)null)
{
missingDependency = (string.IsNullOrEmpty(missingDependency) ? "StartOfRound.Instance.playerJumpSFX" : (missingDependency + "; StartOfRound.Instance.playerJumpSFX"));
return null;
}
return StartOfRound.Instance.playerJumpSFX;
}
internal static void Warn(string message)
{
if (_warningCount < 5)
{
_warningCount++;
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogWarning((object)$"{message} ({_warningCount}/{5})");
}
}
}
}
[HarmonyPatch(typeof(PlayerControllerB), "PlayerJumpedClientRpc")]
internal static class PlayerControllerBPlayerJumpedClientRpcPatch
{
private static Exception Finalizer(Exception __exception)
{
if (__exception is ArgumentOutOfRangeException || __exception is NullReferenceException)
{
PlayerControllerBPlayJumpAudioPatch.Warn("Suppressed PlayerControllerB.PlayerJumpedClientRpc " + __exception.GetType().Name + " from jump audio playback.");
return null;
}
return __exception;
}
}
[HarmonyPatch(typeof(PlayerControllerB), "ThrowObjectClientRpc")]
internal static class PlayerControllerBThrowObjectClientRpcPatch
{
private const int MaxWarnings = 5;
private static readonly Dictionary<string, int> WarningCounts = new Dictionary<string, int>();
private static readonly FieldInfo RpcExecStageField = AccessTools.Field(typeof(NetworkBehaviour), "__rpc_exec_stage");
private static readonly FieldInfo ThrowingObjectField = AccessTools.Field(typeof(PlayerControllerB), "throwingObject");
private static readonly object RpcExecStageSend = ((RpcExecStageField != null) ? Enum.Parse(RpcExecStageField.FieldType, "Send") : null);
private static bool Prefix(PlayerControllerB __instance, bool droppedInElevator, bool droppedInShipRoom, Vector3 targetFloorPosition, NetworkObjectReference grabbedObject, int floorYRot)
{
//IL_0018: 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)
if (!IsExecutingClientRpc(__instance))
{
return true;
}
try
{
HandleThrowObjectClientRpcSafely(__instance, droppedInElevator, droppedInShipRoom, targetFloorPosition, grabbedObject, floorYRot);
}
catch (Exception ex)
{
Warn("guard-failed", "Suppressed ThrowObjectClientRpc because the guard failed safely: " + ex.GetType().Name + ".");
SetRpcExecStageSend(__instance);
if ((Object)(object)__instance != (Object)null && ((NetworkBehaviour)__instance).IsOwner)
{
SetThrowingObject(__instance, value: false);
}
}
return false;
}
private static void HandleThrowObjectClientRpcSafely(PlayerControllerB player, bool droppedInElevator, bool droppedInShipRoom, Vector3 targetFloorPosition, NetworkObjectReference grabbedObject, int floorYRot)
{
//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)player == (Object)null || (Object)(object)((NetworkBehaviour)player).NetworkManager == (Object)null || !((NetworkBehaviour)player).NetworkManager.IsListening || (!((NetworkBehaviour)player).NetworkManager.IsClient && !((NetworkBehaviour)player).NetworkManager.IsHost))
{
return;
}
SetRpcExecStageSend(player);
NetworkObject val = default(NetworkObject);
if (((NetworkObjectReference)(ref grabbedObject)).TryGet(ref val, (NetworkManager)null) && (Object)(object)val != (Object)null)
{
GrabbableObject component = ((Component)val).GetComponent<GrabbableObject>();
if ((Object)(object)component == (Object)null)
{
Warn($"missing-grabbable|{player.playerClientId}", $"Skipped ThrowObjectClientRpc for player #{player.playerClientId} because the NetworkObject had no GrabbableObject.");
FinishThrowingIfOwner(player);
return;
}
if (!((NetworkBehaviour)player).IsOwner)
{
player.SetObjectAsNoLongerHeld(droppedInElevator, droppedInShipRoom, targetFloorPosition, component, floorYRot);
}
if ((Object)(object)component.itemProperties == (Object)null || !component.itemProperties.syncDiscardFunction)
{
component.playerHeldBy = null;
}
if ((Object)(object)component == (Object)(object)player.currentlyHeldObjectServer)
{
player.currentlyHeldObjectServer = null;
}
else
{
Warn($"held-mismatch|{player.playerClientId}", $"Suppressed ThrowObjectClientRpc held-object mismatch for player #{player.playerClientId}; currentlyHeldObjectServer was {GetHeldObjectName(player.currentlyHeldObjectServer)}.");
}
}
else
{
Warn($"missing-network-object|{player.playerClientId}", $"Suppressed ThrowObjectClientRpc because the server object reference was missing for player #{player.playerClientId}.");
}
FinishThrowingIfOwner(player);
}
private static bool IsExecutingClientRpc(PlayerControllerB player)
{
if ((Object)(object)player == (Object)null || RpcExecStageField == null)
{
return false;
}
object value = RpcExecStageField.GetValue(player);
return value != null && value.ToString() == "Execute";
}
private static string GetHeldObjectName(GrabbableObject heldObject)
{
if ((Object)(object)heldObject == (Object)null)
{
return "null";
}
return ((Object)(object)((Component)heldObject).gameObject != (Object)null) ? ((Object)((Component)heldObject).gameObject).name : "missing GameObject";
}
private static void SetRpcExecStageSend(PlayerControllerB player)
{
if ((Object)(object)player != (Object)null && RpcExecStageField != null && RpcExecStageSend != null)
{
RpcExecStageField.SetValue(player, RpcExecStageSend);
}
}
private static void FinishThrowingIfOwner(PlayerControllerB player)
{
if ((Object)(object)player != (Object)null && ((NetworkBehaviour)player).IsOwner)
{
SetThrowingObject(player, value: false);
}
}
private static void SetThrowingObject(PlayerControllerB player, bool value)
{
if ((Object)(object)player != (Object)null && ThrowingObjectField != null)
{
ThrowingObjectField.SetValue(player, value);
}
}
private static void Warn(string key, string message)
{
WarningCounts.TryGetValue(key, out var value);
if (value < 5)
{
value++;
WarningCounts[key] = value;
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogWarning((object)$"{message} ({value}/{5})");
}
}
}
}
[HarmonyPatch(typeof(PlayerControllerB), "GrabObjectClientRpc")]
internal static class PlayerControllerBGrabObjectClientRpcPatch
{
private static readonly WarningLimiter Warnings = new WarningLimiter();
private static Exception Finalizer(PlayerControllerB __instance, Exception __exception)
{
if (__exception is NullReferenceException)
{
Warnings.Warn("GrabObjectClientRpc|" + GetPlayerId(__instance), "Suppressed PlayerControllerB.GrabObjectClientRpc NullReferenceException for player #" + GetPlayerId(__instance) + ".");
return null;
}
return __exception;
}
private static string GetPlayerId(PlayerControllerB player)
{
return ((Object)(object)player != (Object)null) ? player.playerClientId.ToString() : "unknown";
}
}
[HarmonyPatch(typeof(QuicksandTrigger), "OnExit")]
internal static class QuicksandTriggerOnExitPatch
{
private const int MaxWarnings = 5;
private static readonly Dictionary<string, int> WarningCounts = new Dictionary<string, int>();
private static bool Prefix(QuicksandTrigger __instance, Collider other)
{
try
{
HandleExitSafely(__instance, other);
}
catch (Exception ex)
{
Warn("exception", "Suppressed QuicksandTrigger.OnExit failure safely: " + ex.GetType().Name + ".");
}
return false;
}
private static void HandleExitSafely(QuicksandTrigger quicksandTrigger, Collider other)
{
if ((Object)(object)quicksandTrigger == (Object)null || (Object)(object)other == (Object)null)
{
Warn("missing-trigger-or-collider", "Skipped QuicksandTrigger.OnExit because the trigger or collider was missing.");
return;
}
PlayerControllerB val = TryGetPlayer(other);
if ((Object)(object)val == (Object)null)
{
if (((Component)other).CompareTag("Player"))
{
Warn("missing-player", "Skipped QuicksandTrigger.OnExit for '" + ((Object)other).name + "' because no PlayerControllerB was found.");
}
return;
}
if ((Object)(object)GameNetworkManager.Instance == (Object)null)
{
Warn("missing-network-manager", "Skipped QuicksandTrigger.OnExit because GameNetworkManager.Instance was missing.");
return;
}
PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
if (!quicksandTrigger.sinkingLocalPlayer)
{
if (quicksandTrigger.isWater && (Object)(object)val != (Object)(object)localPlayerController)
{
val.isUnderwater = false;
}
}
else if ((Object)(object)val == (Object)(object)localPlayerController)
{
quicksandTrigger.StopSinkingLocalPlayer(val);
}
}
private static PlayerControllerB TryGetPlayer(Collider other)
{
if ((Object)(object)other == (Object)null || (Object)(object)((Component)other).gameObject == (Object)null)
{
return null;
}
return ((Component)other).gameObject.GetComponent<PlayerControllerB>() ?? ((Component)other).GetComponentInParent<PlayerControllerB>();
}
private static void Warn(string key, string message)
{
WarningCounts.TryGetValue(key, out var value);
if (value < 5)
{
value++;
WarningCounts[key] = value;
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogWarning((object)$"{message} ({value}/{5})");
}
}
}
}
[HarmonyPatch(typeof(RedLocustBees), "IsHiveMissing")]
internal static class RedLocustBeesIsHiveMissingPatch
{
private static bool Prefix(RedLocustBees __instance, ref bool __result)
{
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
//IL_00de: Unknown result type (might be due to invalid IL or missing references)
//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
//IL_0125: Unknown result type (might be due to invalid IL or missing references)
//IL_012a: Unknown result type (might be due to invalid IL or missing references)
//IL_0134: Unknown result type (might be due to invalid IL or missing references)
//IL_0139: Unknown result type (might be due to invalid IL or missing references)
//IL_013e: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)__instance == (Object)null || (Object)(object)((EnemyAI)__instance).eye == (Object)null || (Object)(object)StartOfRound.Instance == (Object)null)
{
__result = false;
return false;
}
if ((Object)(object)__instance.hive == (Object)null)
{
__result = true;
return false;
}
float num = Vector3.Distance(((EnemyAI)__instance).eye.position, __instance.lastKnownHivePosition);
if (!Traverse.Create((object)__instance).Field("syncedLastKnownHivePosition").GetValue<bool>())
{
__result = false;
return false;
}
bool flag = num < 8f && !Physics.Linecast(((EnemyAI)__instance).eye.position, __instance.lastKnownHivePosition, StartOfRound.Instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1);
if (num < 4f || flag)
{
if ((Vector3.Distance(((Component)__instance.hive).transform.position, __instance.lastKnownHivePosition) > 6f && !IsHivePlacedAndInLOS(__instance)) || __instance.hive.isHeld)
{
__result = true;
return false;
}
__instance.lastKnownHivePosition = ((Component)__instance.hive).transform.position + Vector3.up * 0.5f;
}
__result = false;
return false;
}
private static Exception Finalizer(Exception __exception)
{
return NullRefGuard.Suppress(__exception, "RedLocustBees.IsHiveMissing");
}
private static bool IsHivePlacedAndInLOS(RedLocustBees bees)
{
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
//IL_006e: 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)
if ((Object)(object)bees.hive == (Object)null || (Object)(object)((EnemyAI)bees).eye == (Object)null || (Object)(object)StartOfRound.Instance == (Object)null || bees.hive.isHeld)
{
return false;
}
return Vector3.Distance(((EnemyAI)bees).eye.position, ((Component)bees.hive).transform.position) <= 9f && !Physics.Linecast(((EnemyAI)bees).eye.position, ((Component)bees.hive).transform.position, StartOfRound.Instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1);
}
}
[HarmonyPatch(typeof(RedLocustBees), "IsHivePlacedAndInLOS")]
internal static class RedLocustBeesIsHivePlacedAndInLOSPatch
{
private static bool Prefix(RedLocustBees __instance, ref bool __result)
{
//IL_0054: Unknown result type (might be due to invalid IL or missing references)
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
//IL_007b: 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 ((Object)(object)__instance == (Object)null || (Object)(object)__instance.hive == (Object)null || (Object)(object)((EnemyAI)__instance).eye == (Object)null || (Object)(object)StartOfRound.Instance == (Object)null || __instance.hive.isHeld)
{
__result = false;
return false;
}
__result = Vector3.Distance(((EnemyAI)__instance).eye.position, ((Component)__instance.hive).transform.position) <= 9f && !Physics.Linecast(((EnemyAI)__instance).eye.position, ((Component)__instance.hive).transform.position, StartOfRound.Instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1);
return false;
}
private static Exception Finalizer(Exception __exception)
{
return NullRefGuard.Suppress(__exception, "RedLocustBees.IsHivePlacedAndInLOS");
}
}
[HarmonyPatch(typeof(RedLocustBees), "DoAIInterval")]
internal static class RedLocustBeesDoAIIntervalPatch
{
private static bool Prefix(RedLocustBees __instance)
{
if ((Object)(object)__instance == (Object)null || (Object)(object)StartOfRound.Instance == (Object)null)
{
return false;
}
if (!Traverse.Create((object)__instance).Field("hasSpawnedHive").GetValue<bool>() || (Object)(object)__instance.hive != (Object)null)
{
return true;
}
((EnemyAI)__instance).targetPlayer = null;
((EnemyAI)__instance).movingTowardsTargetPlayer = false;
if (((EnemyAI)__instance).currentBehaviourStateIndex != 2)
{
((EnemyAI)__instance).SwitchToBehaviourState(2);
}
return false;
}
private static Exception Finalizer(Exception __exception)
{
return NullRefGuard.Suppress(__exception, "RedLocustBees.DoAIInterval");
}
}
[HarmonyPatch(typeof(RedLocustBees), "Update")]
internal static class RedLocustBeesUpdatePatch
{
private static bool Prefix(RedLocustBees __instance)
{
if ((Object)(object)__instance == (Object)null || (Object)(object)StartOfRound.Instance == (Object)null)
{
return false;
}
if ((Object)(object)((EnemyAI)__instance).agent == (Object)null || (Object)(object)__instance.beeParticles == (Object)null || (Object)(object)__instance.beeParticlesTarget == (Object)null)
{
return false;
}
return true;
}
private static Exception Finalizer(Exception __exception)
{
return NullRefGuard.Suppress(__exception, "RedLocustBees.Update");
}
}
[HarmonyPatch(typeof(SandSpiderAI), "PlayerLeaveWebClientRpc")]
internal static class SandSpiderAIPlayerLeaveWebClientRpcPatch
{
private static readonly WarningLimiter Warnings = new WarningLimiter();
private static Exception Finalizer(int trapID, int playerNum, Exception __exception)
{
if (__exception is ArgumentOutOfRangeException)
{
Warnings.Warn($"PlayerLeaveWebClientRpc|trap:{trapID}|player:{playerNum}", $"Suppressed SandSpiderAI.PlayerLeaveWebClientRpc ArgumentOutOfRangeException for trap {trapID}, player {playerNum}.");
return null;
}
return __exception;
}
}
[HarmonyPatch(typeof(GrabbableObjectPhysicsTrigger), "OnTriggerEnter")]
internal static class GrabbableObjectPhysicsTriggerOnTriggerEnterPatch
{
private static readonly WarningLimiter Warnings = new WarningLimiter();
private static bool Prefix(GrabbableObjectPhysicsTrigger __instance, Collider other)
{
if ((Object)(object)__instance?.itemScript != (Object)null && (Object)(object)((other != null) ? ((Component)other).gameObject : null) != (Object)null)
{
return true;
}
Warnings.Warn("missing-trigger-dependency", "Skipped GrabbableObjectPhysicsTrigger.OnTriggerEnter because itemScript or collider was missing.");
return false;
}
private static Exception Finalizer(Exception __exception)
{
if (__exception is NullReferenceException)
{
Warnings.Warn("nre", "Suppressed GrabbableObjectPhysicsTrigger.OnTriggerEnter NullReferenceException.");
return null;
}
return __exception;
}
}
[HarmonyPatch(typeof(SoccerBallProp), "ActivatePhysicsTrigger")]
internal static class SoccerBallPropActivatePhysicsTriggerPatch
{
private static readonly WarningLimiter Warnings = new WarningLimiter();
private static bool Prefix(SoccerBallProp __instance, Collider other)
{
//IL_0092: Unknown result type (might be due to invalid IL or missing references)
//IL_0097: Unknown result type (might be due to invalid IL or missing references)
//IL_009c: Unknown result type (might be due to invalid IL or missing references)
//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
//IL_00df: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)__instance == (Object)null || (Object)(object)((other != null) ? ((Component)other).gameObject : null) == (Object)null)
{
Warnings.Warn("missing-trigger", "Skipped SoccerBallProp.ActivatePhysicsTrigger because the ball or collider was missing.");
return false;
}
GameObject gameObject = ((Component)other).gameObject;
if (!IsPlayerOrEnemy(gameObject))
{
return false;
}
if ((Object)(object)StartOfRound.Instance == (Object)null)
{
Warnings.Warn("missing-startofround", "Skipped SoccerBallProp.ActivatePhysicsTrigger because StartOfRound was not ready.");
return false;
}
Vector3 val = gameObject.transform.position + Vector3.up;
Vector3 val2 = ((Component)__instance).transform.position + Vector3.up * 0.5f;
if (!Physics.Linecast(val, val2, StartOfRound.Instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1))
{
__instance.BeginKickBall(val, gameObject.CompareTag("Enemy"));
}
return false;
}
private static Exception Finalizer(Exception __exception)
{
if (__exception is NullReferenceException)
{
Warnings.Warn("nre", "Suppressed SoccerBallProp.ActivatePhysicsTrigger NullReferenceException.");
return null;
}
return __exception;
}
private static bool IsPlayerOrEnemy(GameObject gameObject)
{
return (Object)(object)gameObject != (Object)null && (gameObject.CompareTag("Player") || gameObject.CompareTag("Enemy"));
}
}
[HarmonyPatch(typeof(SoccerBallProp), "BeginKickBall")]
internal static class SoccerBallPropBeginKickBallPatch
{
private static readonly WarningLimiter Warnings = new WarningLimiter();
private static bool Prefix(SoccerBallProp __instance, bool hitByEnemy)
{
if ((Object)(object)__instance != (Object)null && ((hitByEnemy && !((NetworkBehaviour)__instance).IsServer) || ((GrabbableObject)__instance).isHeld || (Object)(object)((GrabbableObject)__instance).parentObject != (Object)null))
{
return false;
}
if (HasRequiredKickDependencies(__instance))
{
return true;
}
Warnings.Warn("missing-kick-dependency", "Skipped SoccerBallProp.BeginKickBall because required ball, round, player, or ship references were missing.");
return false;
}
private static Exception Finalizer(Exception __exception)
{
if (__exception is NullReferenceException)
{
Warnings.Warn("nre", "Suppressed SoccerBallProp.BeginKickBall NullReferenceException.");
return null;
}
return __exception;
}
private static bool HasRequiredKickDependencies(SoccerBallProp ball)
{
if ((Object)(object)ball == (Object)null || (Object)(object)((Component)ball).transform == (Object)null || (Object)(object)((GrabbableObject)ball).itemProperties == (Object)null)
{
return false;
}
StartOfRound instance = StartOfRound.Instance;
RoundManager instance2 = RoundManager.Instance;
GameNetworkManager instance3 = GameNetworkManager.Instance;
if ((Object)(object)instance == (Object)null || (Object)(object)instance2 == (Object)null || (Object)(object)instance3?.localPlayerController == (Object)null)
{
return false;
}
return (Object)(object)instance.elevatorTransform != (Object)null && (Object)(object)instance.propsContainer != (Object)null && (Object)(object)instance.shipBounds != (Object)null && (Object)(object)instance.shipInnerRoomBounds != (Object)null && (Object)(object)instance2.spawnedScrapContainer != (Object)null;
}
}
[HarmonyPatch(typeof(SoundManager), "PlayAmbienceClipLocal")]
internal static class SoundManagerPlayAmbienceClipLocalPatch
{
private static readonly WarningLimiter Warnings = new WarningLimiter();
private static bool Prefix(SoundManager __instance, int soundType, int clipIndex, float soundVolume, bool playInsanitySounds)
{
try
{
return IsAmbienceClipValid(__instance, soundType, clipIndex, playInsanitySounds);
}
catch (Exception ex)
{
Warnings.Warn("guard-failed", "SoundManager.PlayAmbienceClipLocal guard failed safely and allowed original playback: " + ex.GetType().Name + ".");
return true;
}
}
private static Exception Finalizer(int soundType, int clipIndex, bool playInsanitySounds, Exception __exception)
{
if (__exception is IndexOutOfRangeException)
{
Warnings.Warn($"index-exception|{soundType}|{playInsanitySounds}", $"Suppressed SoundManager.PlayAmbienceClipLocal IndexOutOfRangeException for soundType {soundType}, clipIndex {clipIndex}, playInsanitySounds={playInsanitySounds}.");
return null;
}
return __exception;
}
private static bool IsAmbienceClipValid(SoundManager soundManager, int soundType, int clipIndex, bool playInsanitySounds)
{
if ((Object)(object)soundManager == (Object)null || (Object)(object)soundManager.currentLevelAmbience == (Object)null)
{
Warnings.Warn("missing-ambience", "Skipped SoundManager.PlayAmbienceClipLocal because currentLevelAmbience was missing.");
return false;
}
if (clipIndex < 0)
{
Warnings.Warn($"negative-index|{soundType}|{playInsanitySounds}", $"Skipped SoundManager.PlayAmbienceClipLocal because clipIndex {clipIndex} was negative for soundType {soundType}.");
return false;
}
LevelAmbienceLibrary currentLevelAmbience = soundManager.currentLevelAmbience;
if (playInsanitySounds)
{
return IsInsanityClipValid(currentLevelAmbience, soundType, clipIndex);
}
return IsNormalClipValid(currentLevelAmbience, soundType, clipIndex);
}
private static bool IsNormalClipValid(LevelAmbienceLibrary ambience, int soundType, int clipIndex)
{
if (1 == 0)
{
}
AudioClip[] array = soundType switch
{
0 => ambience.insideAmbience,
1 => ambience.outsideAmbience,
2 => ambience.shipAmbience,
_ => null,
};
if (1 == 0)
{
}
AudioClip[] array2 = array;
if (array2 != null && clipIndex < array2.Length && (Object)(object)array2[clipIndex] != (Object)null)
{
return true;
}
WarnInvalidIndex(soundType, clipIndex, playInsanitySounds: false, (array2 != null) ? array2.Length : 0);
return false;
}
private static bool IsInsanityClipValid(LevelAmbienceLibrary ambience, int soundType, int clipIndex)
{
if (1 == 0)
{
}
RandomAudioClip[] array = soundType switch
{
0 => ambience.insideAmbienceInsanity,
1 => ambience.outsideAmbienceInsanity,
2 => ambience.shipAmbienceInsanity,
_ => null,
};
if (1 == 0)
{
}
RandomAudioClip[] array2 = array;
if (array2 != null && clipIndex < array2.Length && array2[clipIndex] != null && (Object)(object)array2[clipIndex].audioClip != (Object)null)
{
return true;
}
WarnInvalidIndex(soundType, clipIndex, playInsanitySounds:
