using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using UnityEngine;
using UnityEngine.SceneManagement;
[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: IgnoresAccessChecksTo("")]
[assembly: AssemblyCompany("REPOJP")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("REPOJP")]
[assembly: AssemblyTitle("REPOJP")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace ExtractionAutoRevive
{
[BepInPlugin("com.repojp.extractionautorevive", "ExtractionAutoRevive", "1.2.0")]
public sealed class ExtractionAutoRevivePlugin : BaseUnityPlugin
{
private sealed class PendingReviveEntry
{
public PlayerDeathHead DeathHead;
public PlayerAvatar PlayerAvatar;
public int Key;
public float QueuedAt;
public float ElectrifiedEndedAt = -1f;
public float VelocityStableStartedAt = -1f;
public string PlayerLabel;
}
[CompilerGenerated]
private sealed class <MonitorPendingRevives>d__37 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public ExtractionAutoRevivePlugin <>4__this;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <MonitorPendingRevives>d__37(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0106: Unknown result type (might be due to invalid IL or missing references)
//IL_0110: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
break;
case 1:
<>1__state = -1;
break;
}
while (<>4__this.pendingRevives.Count > 0)
{
if (!<>4__this.IsModEnabled())
{
<>4__this.ClearPendingRevives("mod disabled");
break;
}
if (!<>4__this.CanRunHostLogic())
{
<>4__this.ClearPendingRevives("host lost");
break;
}
if (<>4__this.ShouldClearPendingByRoundState())
{
<>4__this.ClearPendingRevives("round transition");
break;
}
<>4__this.ProcessPendingRevives();
if (<>4__this.pendingRevives.Count > 0)
{
<>2__current = (object)new WaitForSecondsRealtime(Mathf.Clamp(<>4__this.configPendingCheckIntervalSeconds.Value, 0.02f, 1f));
<>1__state = 1;
return true;
}
}
<>4__this.pendingMonitorCoroutine = null;
<>4__this.WriteVerbose("Pending monitor stopped");
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();
}
}
internal static ExtractionAutoRevivePlugin Instance;
internal static ManualLogSource Log;
private Harmony harmony;
private static int customReviveContextDepth;
private Coroutine pendingMonitorCoroutine;
private readonly Dictionary<int, PendingReviveEntry> pendingRevives = new Dictionary<int, PendingReviveEntry>();
private ConfigEntry<bool> configEnableMod;
private ConfigEntry<bool> configEnableLog;
private ConfigEntry<bool> configEnableVerboseLog;
private ConfigEntry<float> configPitHeadExtraDelaySeconds;
private ConfigEntry<float> configPitHeadMaxVelocityToRevive;
private ConfigEntry<float> configPendingCheckIntervalSeconds;
private static readonly FieldInfo FieldPlayerAvatarDeadSet = AccessTools.Field(typeof(PlayerAvatar), "deadSet");
private static readonly FieldInfo FieldPlayerAvatarIsDisabled = AccessTools.Field(typeof(PlayerAvatar), "isDisabled");
private static readonly FieldInfo FieldPlayerAvatarFinalHeal = AccessTools.Field(typeof(PlayerAvatar), "finalHeal");
private static readonly FieldInfo FieldPlayerDeathHeadTriggered = AccessTools.Field(typeof(PlayerDeathHead), "triggered");
private static readonly FieldInfo FieldPlayerDeathHeadInExtractionPoint = AccessTools.Field(typeof(PlayerDeathHead), "inExtractionPoint");
private static readonly FieldInfo FieldPlayerDeathHeadInTruck = AccessTools.Field(typeof(PlayerDeathHead), "inTruck");
private static readonly FieldInfo FieldPlayerDeathHeadPhysGrabObject = AccessTools.Field(typeof(PlayerDeathHead), "physGrabObject");
private static readonly FieldInfo FieldPhysGrabObjectDeathPitEffect = AccessTools.Field(typeof(PhysGrabObject), "deathPitEffect");
private static readonly FieldInfo FieldPhysGrabObjectDeathPitEffectDisableTimer = AccessTools.Field(typeof(PhysGrabObject), "deathPitEffectDisableTimer");
private static readonly FieldInfo FieldDeathPitSaveEffectTimeCurrent = AccessTools.Field(typeof(DeathPitSaveEffect), "timeCurrent");
private void Awake()
{
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_0074: Expected O, but got Unknown
try
{
((Component)this).transform.parent = null;
Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
}
catch (Exception arg)
{
((BaseUnityPlugin)this).Logger.LogWarning((object)$"[ExtractionAutoRevive] Persist setup failed ex={arg}");
}
Instance = this;
Log = ((BaseUnityPlugin)this).Logger;
SetupConfig();
SceneManager.activeSceneChanged += OnActiveSceneChanged;
harmony = new Harmony("com.repojp.extractionautorevive");
harmony.PatchAll();
WriteLog("Loaded");
}
private void OnDestroy()
{
ClearPendingRevives("plugin destroy");
SceneManager.activeSceneChanged -= OnActiveSceneChanged;
try
{
if (harmony != null)
{
harmony.UnpatchSelf();
}
}
catch (Exception arg)
{
((BaseUnityPlugin)this).Logger.LogWarning((object)$"[ExtractionAutoRevive] Unpatch failed ex={arg}");
}
if (Instance == this)
{
Instance = null;
}
}
private void SetupConfig()
{
//IL_0093: Unknown result type (might be due to invalid IL or missing references)
//IL_009d: Expected O, but got Unknown
//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
//IL_00db: Expected O, but got Unknown
//IL_010f: Unknown result type (might be due to invalid IL or missing references)
//IL_0119: Expected O, but got Unknown
configEnableMod = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "EnableMod", true, "MOD overall enable switch");
configEnableLog = ((BaseUnityPlugin)this).Config.Bind<bool>("Log", "EnableLog", true, "Enable standard logs");
configEnableVerboseLog = ((BaseUnityPlugin)this).Config.Bind<bool>("Log", "EnableVerboseLog", false, "Enable verbose logs");
configPitHeadExtraDelaySeconds = ((BaseUnityPlugin)this).Config.Bind<float>("PitHead", "PitHeadExtraDelaySeconds", 0.35f, new ConfigDescription("Additional delay after death pit electricity ends", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 5f), Array.Empty<object>()));
configPitHeadMaxVelocityToRevive = ((BaseUnityPlugin)this).Config.Bind<float>("PitHead", "PitHeadMaxVelocityToRevive", 1f, new ConfigDescription("Maximum rigidbody velocity magnitude allowed before revive", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 20f), Array.Empty<object>()));
configPendingCheckIntervalSeconds = ((BaseUnityPlugin)this).Config.Bind<float>("PitHead", "PendingCheckIntervalSeconds", 0.05f, new ConfigDescription("Pending pit head monitor interval", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.02f, 1f), Array.Empty<object>()));
}
private void OnActiveSceneChanged(Scene previousScene, Scene nextScene)
{
ClearPendingRevives("scene changed " + ((Scene)(ref previousScene)).name + " -> " + ((Scene)(ref nextScene)).name);
}
private void WriteLog(string message)
{
if (configEnableLog != null && configEnableLog.Value)
{
Log.LogInfo((object)("[ExtractionAutoRevive] " + message));
}
}
private void WriteVerbose(string message)
{
if (configEnableVerboseLog != null && configEnableVerboseLog.Value)
{
Log.LogInfo((object)("[ExtractionAutoRevive] " + message));
}
}
private void WriteWarning(string message)
{
Log.LogWarning((object)("[ExtractionAutoRevive] " + message));
}
internal static void EnterCustomReviveContext()
{
customReviveContextDepth++;
}
internal static void ExitCustomReviveContext()
{
if (customReviveContextDepth > 0)
{
customReviveContextDepth--;
}
}
internal static bool IsCustomReviveContextActive()
{
return customReviveContextDepth > 0;
}
internal bool IsModEnabled()
{
return configEnableMod != null && configEnableMod.Value;
}
internal void HandleDeathHeadRevive(PlayerDeathHead deathHead)
{
if (IsModEnabled() && !((Object)(object)deathHead == (Object)null))
{
PlayerAvatar playerAvatar = deathHead.playerAvatar;
DeathPitSaveEffect effect;
if ((Object)(object)playerAvatar == (Object)null)
{
WriteWarning("Skip custom revive reason=playerAvatar null");
}
else if (!IsPlayerDead(playerAvatar, deathHead))
{
WriteVerbose("Skip custom revive player=" + GetPlayerLabel(playerAvatar) + " reason=alreadyAlive");
}
else if (!GetBoolField(FieldPlayerDeathHeadTriggered, deathHead, defaultValue: false))
{
WriteVerbose("Skip custom revive player=" + GetPlayerLabel(playerAvatar) + " reason=headNotTriggered");
}
else if (IsPitHeadElectrified(deathHead, out effect))
{
EnqueuePendingRevive(deathHead, playerAvatar);
}
else
{
ReviveNow(playerAvatar, "immediate");
}
}
}
private void EnqueuePendingRevive(PlayerDeathHead deathHead, PlayerAvatar playerAvatar)
{
if (!((Object)(object)deathHead == (Object)null) && !((Object)(object)playerAvatar == (Object)null))
{
int num = GetPendingKey(playerAvatar, deathHead);
if (num == 0)
{
num = ((Object)playerAvatar).GetInstanceID();
}
if (pendingRevives.TryGetValue(num, out PendingReviveEntry value))
{
value.DeathHead = deathHead;
value.PlayerAvatar = playerAvatar;
value.PlayerLabel = GetPlayerLabel(playerAvatar);
WriteVerbose($"Refresh pending revive player={value.PlayerLabel} key={num}");
StartPendingMonitorIfNeeded();
}
else
{
PendingReviveEntry pendingReviveEntry = new PendingReviveEntry
{
DeathHead = deathHead,
PlayerAvatar = playerAvatar,
Key = num,
QueuedAt = Time.unscaledTime,
PlayerLabel = GetPlayerLabel(playerAvatar)
};
pendingRevives[num] = pendingReviveEntry;
WriteLog($"Queue delayed revive player={pendingReviveEntry.PlayerLabel} key={num}");
StartPendingMonitorIfNeeded();
}
}
}
private void StartPendingMonitorIfNeeded()
{
if (pendingRevives.Count > 0 && pendingMonitorCoroutine == null)
{
pendingMonitorCoroutine = ((MonoBehaviour)this).StartCoroutine(MonitorPendingRevives());
WriteVerbose("Pending monitor started");
}
}
[IteratorStateMachine(typeof(<MonitorPendingRevives>d__37))]
private IEnumerator MonitorPendingRevives()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <MonitorPendingRevives>d__37(0)
{
<>4__this = this
};
}
private void ProcessPendingRevives()
{
if (pendingRevives.Count <= 0)
{
return;
}
List<int> list = new List<int>(pendingRevives.Keys);
foreach (int item in list)
{
if (!pendingRevives.TryGetValue(item, out PendingReviveEntry value))
{
continue;
}
if (value == null || (Object)(object)value.PlayerAvatar == (Object)null || (Object)(object)value.DeathHead == (Object)null)
{
RemovePendingRevive(item, "invalid reference");
continue;
}
if (!IsPlayerDead(value.PlayerAvatar, value.DeathHead))
{
RemovePendingRevive(item, "already alive");
continue;
}
if (!GetBoolField(FieldPlayerDeathHeadTriggered, value.DeathHead, defaultValue: false))
{
RemovePendingRevive(item, "head no longer triggered");
continue;
}
if (ShouldLeaveToVanillaTruckRevive(value.DeathHead, value.PlayerAvatar))
{
RemovePendingRevive(item, "vanilla truck revive");
continue;
}
if (IsPitHeadElectrified(value.DeathHead, out DeathPitSaveEffect _))
{
value.ElectrifiedEndedAt = -1f;
value.VelocityStableStartedAt = -1f;
WriteVerbose("Pending wait player=" + value.PlayerLabel + " reason=electrified");
continue;
}
if (value.ElectrifiedEndedAt < 0f)
{
value.ElectrifiedEndedAt = Time.unscaledTime;
value.VelocityStableStartedAt = -1f;
WriteVerbose("Pending electricity ended player=" + value.PlayerLabel);
}
float num = Time.unscaledTime - value.ElectrifiedEndedAt;
if (num < configPitHeadExtraDelaySeconds.Value)
{
WriteVerbose($"Pending extra delay player={value.PlayerLabel} elapsed={num:F2}");
continue;
}
float headVelocityMagnitude = GetHeadVelocityMagnitude(value.DeathHead);
if (headVelocityMagnitude > configPitHeadMaxVelocityToRevive.Value)
{
value.VelocityStableStartedAt = -1f;
WriteVerbose($"Pending velocity wait player={value.PlayerLabel} velocity={headVelocityMagnitude:F2}");
continue;
}
if (value.VelocityStableStartedAt < 0f)
{
value.VelocityStableStartedAt = Time.unscaledTime;
WriteVerbose("Pending velocity stable start player=" + value.PlayerLabel);
}
ReviveNow(value.PlayerAvatar, "delayed");
RemovePendingRevive(item, "revived");
}
}
private void RemovePendingRevive(int key, string reason)
{
if (pendingRevives.TryGetValue(key, out PendingReviveEntry value))
{
WriteVerbose($"Pending remove player={value.PlayerLabel} key={key} reason={reason}");
pendingRevives.Remove(key);
}
}
internal void ClearPendingRevives(string reason)
{
if (pendingRevives.Count > 0)
{
WriteLog($"Clear pending revives count={pendingRevives.Count} reason={reason}");
pendingRevives.Clear();
}
}
private bool CanRunHostLogic()
{
try
{
return SemiFunc.IsMasterClientOrSingleplayer();
}
catch
{
return false;
}
}
private bool ShouldClearPendingByRoundState()
{
try
{
if ((Object)(object)RunManager.instance == (Object)null)
{
return false;
}
if (SemiFunc.RunIsLobby() || SemiFunc.RunIsLobbyMenu() || (!SemiFunc.RunIsShop() && !SemiFunc.RunIsLevel()))
{
return true;
}
if ((Object)(object)RoundDirector.instance != (Object)null && RoundDirector.instance.allExtractionPointsCompleted)
{
return true;
}
}
catch
{
return true;
}
return false;
}
private bool ShouldLeaveToVanillaTruckRevive(PlayerDeathHead deathHead, PlayerAvatar playerAvatar)
{
if ((Object)(object)deathHead == (Object)null || (Object)(object)playerAvatar == (Object)null)
{
return false;
}
if ((Object)(object)RoundDirector.instance == (Object)null)
{
return false;
}
if (!RoundDirector.instance.allExtractionPointsCompleted)
{
return false;
}
if (GetBoolField(FieldPlayerAvatarFinalHeal, playerAvatar, defaultValue: false))
{
return false;
}
if (!GetBoolField(FieldPlayerDeathHeadInTruck, deathHead, defaultValue: false))
{
return false;
}
return true;
}
private bool IsPlayerDead(PlayerAvatar playerAvatar, PlayerDeathHead deathHead)
{
if ((Object)(object)playerAvatar == (Object)null)
{
return false;
}
bool boolField = GetBoolField(FieldPlayerAvatarDeadSet, playerAvatar, defaultValue: false);
bool boolField2 = GetBoolField(FieldPlayerAvatarIsDisabled, playerAvatar, defaultValue: false);
bool activeSelf = ((Component)playerAvatar).gameObject.activeSelf;
bool flag = (Object)(object)deathHead != (Object)null && GetBoolField(FieldPlayerDeathHeadTriggered, deathHead, defaultValue: false);
if (boolField)
{
return true;
}
if (boolField2)
{
return true;
}
if (!activeSelf)
{
return true;
}
if (flag)
{
return true;
}
return false;
}
private void ReviveNow(PlayerAvatar playerAvatar, string reason)
{
if ((Object)(object)playerAvatar == (Object)null)
{
return;
}
if (!IsPlayerDead(playerAvatar, playerAvatar.playerDeathHead))
{
WriteVerbose("Skip revive player=" + GetPlayerLabel(playerAvatar) + " reason=alreadyAlive finalReason=" + reason);
return;
}
try
{
playerAvatar.Revive(true);
WriteLog("Revive(true) player=" + GetPlayerLabel(playerAvatar) + " reason=" + reason);
}
catch (Exception arg)
{
WriteWarning($"Revive(true) failed player={GetPlayerLabel(playerAvatar)} reason={reason} ex={arg}");
}
}
private bool IsPitHeadElectrified(PlayerDeathHead deathHead, out DeathPitSaveEffect effect)
{
effect = null;
if ((Object)(object)deathHead == (Object)null)
{
return false;
}
PhysGrabObject playerDeathHeadPhysGrabObject = GetPlayerDeathHeadPhysGrabObject(deathHead);
if ((Object)(object)playerDeathHeadPhysGrabObject == (Object)null)
{
return false;
}
float floatField = GetFloatField(FieldPhysGrabObjectDeathPitEffectDisableTimer, playerDeathHeadPhysGrabObject, 0f);
GameObject gameObjectField = GetGameObjectField(FieldPhysGrabObjectDeathPitEffect, playerDeathHeadPhysGrabObject);
if ((Object)(object)gameObjectField == (Object)null)
{
if (floatField > 0f)
{
return false;
}
return false;
}
effect = gameObjectField.GetComponent<DeathPitSaveEffect>();
if ((Object)(object)effect == (Object)null)
{
return false;
}
if ((Object)(object)effect.physGrabObject != (Object)null && (Object)(object)effect.physGrabObject != (Object)(object)playerDeathHeadPhysGrabObject)
{
return false;
}
float floatField2 = GetFloatField(FieldDeathPitSaveEffectTimeCurrent, effect, 0f);
if (floatField2 > 0f)
{
return true;
}
return false;
}
private float GetHeadVelocityMagnitude(PlayerDeathHead deathHead)
{
//IL_0052: 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)
if ((Object)(object)deathHead == (Object)null)
{
return 0f;
}
PhysGrabObject playerDeathHeadPhysGrabObject = GetPlayerDeathHeadPhysGrabObject(deathHead);
if ((Object)(object)playerDeathHeadPhysGrabObject == (Object)null)
{
return 0f;
}
if ((Object)(object)playerDeathHeadPhysGrabObject.rb == (Object)null)
{
return 0f;
}
Vector3 velocity = playerDeathHeadPhysGrabObject.rb.velocity;
return ((Vector3)(ref velocity)).magnitude;
}
private int GetPendingKey(PlayerAvatar playerAvatar, PlayerDeathHead deathHead)
{
if ((Object)(object)playerAvatar != (Object)null && (Object)(object)playerAvatar.photonView != (Object)null && playerAvatar.photonView.ViewID > 0)
{
return playerAvatar.photonView.ViewID;
}
PhotonView val = null;
if ((Object)(object)deathHead != (Object)null)
{
val = ((Component)deathHead).GetComponent<PhotonView>();
}
if ((Object)(object)val != (Object)null && val.ViewID > 0)
{
return val.ViewID;
}
if ((Object)(object)playerAvatar != (Object)null)
{
return ((Object)playerAvatar).GetInstanceID();
}
return 0;
}
private string GetPlayerLabel(PlayerAvatar playerAvatar)
{
if ((Object)(object)playerAvatar == (Object)null)
{
return "null";
}
if (!string.IsNullOrEmpty(((Object)playerAvatar).name))
{
return ((Object)playerAvatar).name;
}
return "PlayerAvatar";
}
private PhysGrabObject GetPlayerDeathHeadPhysGrabObject(PlayerDeathHead deathHead)
{
if ((Object)(object)deathHead == (Object)null)
{
return null;
}
PhysGrabObject val = null;
if (FieldPlayerDeathHeadPhysGrabObject != null)
{
try
{
object? value = FieldPlayerDeathHeadPhysGrabObject.GetValue(deathHead);
val = (PhysGrabObject)((value is PhysGrabObject) ? value : null);
}
catch
{
}
}
if ((Object)(object)val != (Object)null)
{
return val;
}
return ((Component)deathHead).GetComponent<PhysGrabObject>();
}
private static bool GetBoolField(FieldInfo fieldInfo, object instance, bool defaultValue)
{
if (fieldInfo == null || instance == null)
{
return defaultValue;
}
try
{
object value = fieldInfo.GetValue(instance);
if (value is bool)
{
return (bool)value;
}
}
catch
{
}
return defaultValue;
}
private static float GetFloatField(FieldInfo fieldInfo, object instance, float defaultValue)
{
if (fieldInfo == null || instance == null)
{
return defaultValue;
}
try
{
object value = fieldInfo.GetValue(instance);
if (value is float)
{
return (float)value;
}
}
catch
{
}
return defaultValue;
}
private static GameObject GetGameObjectField(FieldInfo fieldInfo, object instance)
{
if (fieldInfo == null || instance == null)
{
return null;
}
try
{
object? value = fieldInfo.GetValue(instance);
return (GameObject)((value is GameObject) ? value : null);
}
catch
{
return null;
}
}
}
[HarmonyPatch(typeof(ExtractionPoint), "DestroyAllPhysObjectsInShoppingList")]
internal static class ExtractionPoint_DestroyAllPhysObjectsInShoppingList_Patch
{
private static void Prefix()
{
if (SemiFunc.IsMasterClientOrSingleplayer())
{
ExtractionAutoRevivePlugin.EnterCustomReviveContext();
}
}
private static Exception Finalizer(Exception __exception)
{
if (SemiFunc.IsMasterClientOrSingleplayer())
{
ExtractionAutoRevivePlugin.ExitCustomReviveContext();
}
return __exception;
}
}
[HarmonyPatch(typeof(ExtractionPoint), "DestroyAllPhysObjectsInHaulList")]
internal static class ExtractionPoint_DestroyAllPhysObjectsInHaulList_Patch
{
private static void Prefix()
{
if (SemiFunc.IsMasterClientOrSingleplayer())
{
ExtractionAutoRevivePlugin.EnterCustomReviveContext();
}
}
private static Exception Finalizer(Exception __exception)
{
if (SemiFunc.IsMasterClientOrSingleplayer())
{
ExtractionAutoRevivePlugin.ExitCustomReviveContext();
}
return __exception;
}
}
[HarmonyPatch(typeof(PlayerDeathHead), "Revive")]
internal static class PlayerDeathHead_Revive_Patch
{
private static bool Prefix(PlayerDeathHead __instance)
{
if (!ExtractionAutoRevivePlugin.IsCustomReviveContextActive())
{
return true;
}
if ((Object)(object)ExtractionAutoRevivePlugin.Instance == (Object)null)
{
return true;
}
if (!ExtractionAutoRevivePlugin.Instance.IsModEnabled())
{
return true;
}
try
{
ExtractionAutoRevivePlugin.Instance.HandleDeathHeadRevive(__instance);
}
catch (Exception arg)
{
ManualLogSource log = ExtractionAutoRevivePlugin.Log;
if (log != null)
{
log.LogWarning((object)$"[ExtractionAutoRevive] PlayerDeathHead.Revive patch failed ex={arg}");
}
}
return false;
}
}
[HarmonyPatch(typeof(RunManager), "ChangeLevel")]
internal static class RunManager_ChangeLevel_Patch
{
private static void Prefix()
{
if ((Object)(object)ExtractionAutoRevivePlugin.Instance != (Object)null)
{
ExtractionAutoRevivePlugin.Instance.ClearPendingRevives("run manager change level");
}
}
}
[HarmonyPatch(typeof(RunManager), "RestartScene")]
internal static class RunManager_RestartScene_Patch
{
private static void Prefix()
{
if ((Object)(object)ExtractionAutoRevivePlugin.Instance != (Object)null)
{
ExtractionAutoRevivePlugin.Instance.ClearPendingRevives("run manager restart scene");
}
}
}
[HarmonyPatch(typeof(RoundDirector), "ExtractionCompletedAllRPC")]
internal static class RoundDirector_ExtractionCompletedAllRPC_Patch
{
private static void Postfix()
{
if ((Object)(object)ExtractionAutoRevivePlugin.Instance != (Object)null)
{
ExtractionAutoRevivePlugin.Instance.ClearPendingRevives("all extractions completed");
}
}
}
[HarmonyPatch(typeof(TruckHealer), "StateUpdate")]
internal static class TruckHealer_StateUpdate_Patch
{
private static void Prefix(State _newState)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0003: Invalid comparison between Unknown and I4
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Invalid comparison between Unknown and I4
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_000b: Invalid comparison between Unknown and I4
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
if (((int)_newState == 1 || (int)_newState == 2 || (int)_newState == 3) && (Object)(object)ExtractionAutoRevivePlugin.Instance != (Object)null)
{
ExtractionAutoRevivePlugin.Instance.ClearPendingRevives($"truck healer state={_newState}");
}
}
}
}
