using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
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 TMPro;
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: AssemblyCompany("QNCNXW8R")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+d0d59f8b85e99fdf63a7645c43621de0dce46fb6")]
[assembly: AssemblyProduct("FindRemainingValuables")]
[assembly: AssemblyTitle("FindRemainingValuables")]
[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 FindRemainingValuables
{
[BepInPlugin("QNCNXW8R.FindRemainingValuables", "FindRemainingValuables", "2.5.0")]
public class FindRemainingValuables : BaseUnityPlugin
{
[CompilerGenerated]
private sealed class <EnableHaulUIAfterDelay>d__35 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public HaulUI ui;
public float delay;
public FindRemainingValuables <>4__this;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <EnableHaulUIAfterDelay>d__35(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(delay);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
((Behaviour)ui).enabled = true;
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();
}
}
[CompilerGenerated]
private sealed class <PeriodicValueCheck>d__31 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public FindRemainingValuables <>4__this;
private ValuableObject[] <valuables>5__1;
private float <totalValue>5__2;
private RoundDirector <director>5__3;
private float <undiscoveredValue>5__4;
private float <currentHaul>5__5;
private int <goal>5__6;
private float <threshold>5__7;
private float <remainingValue>5__8;
private float <thresholdValue>5__9;
private int <totalPoints>5__10;
private int <completedPoints>5__11;
private float <goalPerPoint>5__12;
private List<GameObject>.Enumerator <>s__13;
private GameObject <pointObj>5__14;
private ExtractionPoint <point>5__15;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <PeriodicValueCheck>d__31(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<valuables>5__1 = null;
<director>5__3 = null;
<>s__13 = default(List<GameObject>.Enumerator);
<pointObj>5__14 = null;
<point>5__15 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Expected O, but got Unknown
//IL_029c: Unknown result type (might be due to invalid IL or missing references)
//IL_02a2: Invalid comparison between Unknown and I4
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
break;
case 1:
<>1__state = -1;
<valuables>5__1 = Object.FindObjectsOfType<ValuableObject>();
<totalValue>5__2 = <valuables>5__1.Sum((ValuableObject v) => v.dollarValueCurrent);
<director>5__3 = Object.FindObjectOfType<RoundDirector>();
if ((Object)(object)<director>5__3 == (Object)null || !SemiFunc.RunIsLevel())
{
break;
}
<>4__this.isHostOrSingleplayer = !GameManager.Multiplayer() || PhotonNetwork.IsMasterClient;
if (<>4__this.awaitingActiveExtraction && <director>5__3.extractionPointActive && (Object)(object)<director>5__3.extractionPointCurrent != (Object)null)
{
<>4__this.awaitingActiveExtraction = false;
<>4__this.AlertEnemies();
}
<undiscoveredValue>5__4 = <valuables>5__1.Where((ValuableObject v) => !v.discovered).Sum((ValuableObject v) => v.dollarValueCurrent);
<>4__this.previousRemainingValue = <undiscoveredValue>5__4;
if (<undiscoveredValue>5__4 == 0f && <>4__this.previousRemainingValue > 0f)
{
<>4__this.ForceReveal();
}
<currentHaul>5__5 = <director>5__3.currentHaul;
if (GoalType.Value == "LevelGoal")
{
<goal>5__6 = <director>5__3.haulGoal;
<totalPoints>5__10 = <director>5__3.extractionPoints;
<completedPoints>5__11 = <director>5__3.extractionPointsCompleted;
if (<totalPoints>5__10 > 0 && <director>5__3.extractionPointList != null)
{
<goalPerPoint>5__12 = (float)<director>5__3.haulGoal / (float)<totalPoints>5__10;
<>s__13 = <director>5__3.extractionPointList.GetEnumerator();
try
{
while (<>s__13.MoveNext())
{
<pointObj>5__14 = <>s__13.Current;
<point>5__15 = <pointObj>5__14.GetComponent<ExtractionPoint>();
if ((Object)(object)<point>5__15 != (Object)null && (int)<point>5__15.currentState == 7)
{
<currentHaul>5__5 += <goalPerPoint>5__12;
}
<point>5__15 = null;
<pointObj>5__14 = null;
}
}
finally
{
((IDisposable)<>s__13).Dispose();
}
<>s__13 = default(List<GameObject>.Enumerator);
}
}
else if (GoalType.Value == "ExtractionGoal")
{
<goal>5__6 = <director>5__3.extractionHaulGoal;
}
else if (GoalType.Value == "LevelLoot")
{
<goal>5__6 = (int)<totalValue>5__2;
}
else
{
<goal>5__6 = 1;
}
<threshold>5__7 = RevealThreshold.Value;
if (GoalType.Value == "Extractions")
{
<remainingValue>5__8 = <director>5__3.extractionPoints - <director>5__3.extractionPointsCompleted;
}
else if (TrackingMethod.Value == "Haul")
{
<remainingValue>5__8 = <totalValue>5__2 - <currentHaul>5__5;
}
else
{
<remainingValue>5__8 = <undiscoveredValue>5__4;
}
<thresholdValue>5__9 = (float)<goal>5__6 * <threshold>5__7;
if (<remainingValue>5__8 <= <thresholdValue>5__9 && <goal>5__6 > 0 && (<director>5__3.extractionPointActive || <director>5__3.extractionPointsCompleted > 0) && <>4__this.isHostOrSingleplayer)
{
<>4__this.ForceReveal();
<>4__this.previousRemainingValue = 0f;
}
if ((EnableLogging?.Value).Value)
{
Logger.LogInfo((object)$"Current Haul: {<currentHaul>5__5}, Goal: {<goal>5__6}");
Logger.LogInfo((object)$"Missing Value: {<remainingValue>5__8}, Threshold: {<thresholdValue>5__9}");
}
<valuables>5__1 = null;
<director>5__3 = null;
break;
}
<>2__current = (object)new WaitForSeconds(5f);
<>1__state = 1;
return true;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
private bool isHostOrSingleplayer = false;
private bool sceneReady = false;
private bool hasRevealedThisScene = false;
private float previousRemainingValue = -1f;
private bool awaitingActiveExtraction = false;
public static ConfigEntry<float>? RevealThreshold;
public static ConfigEntry<string>? TrackingMethod;
public static ConfigEntry<string>? GoalType;
public static ConfigEntry<bool>? NotificationSound;
public static ConfigEntry<bool>? EnemiesRespond;
public static ConfigEntry<string>? AlertDifficulty;
public static ConfigEntry<bool>? EnableHotkeys;
public static ConfigEntry<KeyboardShortcut>? RevealKeybind;
public static ConfigEntry<bool>? EnableLogging;
internal static FindRemainingValuables Instance { get; private set; }
internal static ManualLogSource Logger => Instance._logger;
private ManualLogSource _logger => ((BaseUnityPlugin)this).Logger;
internal Harmony? Harmony { get; set; }
private void Awake()
{
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_0040: Expected O, but got Unknown
//IL_007f: Unknown result type (might be due to invalid IL or missing references)
//IL_0089: Expected O, but got Unknown
//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
//IL_00e2: Expected O, but got Unknown
//IL_0179: Unknown result type (might be due to invalid IL or missing references)
//IL_0183: Expected O, but got Unknown
//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
//IL_01db: Unknown result type (might be due to invalid IL or missing references)
//IL_01e5: Expected O, but got Unknown
Instance = this;
RevealThreshold = ((BaseUnityPlugin)this).Config.Bind<float>("General", "RevealThreshold", 0.1f, new ConfigDescription("Proportion of goal remaining before revealing all valuables: 0 is never, 1 is always in LevelLoot mode, 4 is probably always in other modes", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 4f), Array.Empty<object>()));
TrackingMethod = ((BaseUnityPlugin)this).Config.Bind<string>("General", "TrackingMethod", "Haul", new ConfigDescription("Method to track progress towards the threshold", (AcceptableValueBase)(object)new AcceptableValueList<string>(new string[2] { "Haul", "Discovery" }), Array.Empty<object>()));
GoalType = ((BaseUnityPlugin)this).Config.Bind<string>("General", "GoalType", "LevelLoot", new ConfigDescription("Which goal to use when calculating reveal threshold: ExtractionGoal, LevelGoal, LevelLoot, Extractions", (AcceptableValueBase)(object)new AcceptableValueList<string>(new string[4] { "ExtractionGoal", "LevelGoal", "LevelLoot", "Extractions" }), Array.Empty<object>()));
NotificationSound = ((BaseUnityPlugin)this).Config.Bind<bool>("Notification", "NotificationSound", true, "If true, enables the notification sound when the reveal is triggered");
EnemiesRespond = ((BaseUnityPlugin)this).Config.Bind<bool>("Notification", "EnemiesRespond", false, "If true, causes enemies to investigate when the reveal is triggered");
AlertDifficulty = ((BaseUnityPlugin)this).Config.Bind<string>("Notification", "AlertDifficulty", "Investigate", new ConfigDescription("How strongly enemies respond when valuables are revealed", (AcceptableValueBase)(object)new AcceptableValueList<string>(new string[5] { "Investigate", "Sweep", "Purge", "Annihilation", "Dynamic" }), Array.Empty<object>()));
EnableHotkeys = ((BaseUnityPlugin)this).Config.Bind<bool>("Controls", "EnableHotkeys", true, "If true, enables hotkeys");
RevealKeybind = ((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("Controls", "RevealKeybind", new KeyboardShortcut((KeyCode)291, Array.Empty<KeyCode>()), new ConfigDescription("Key to press to reveal all remaining valuables", (AcceptableValueBase)null, new object[1] { "HideFromREPOConfig" }));
EnableLogging = ((BaseUnityPlugin)this).Config.Bind<bool>("Debug", "EnableLogging", false, "If true, prints debug data to console");
((Component)this).gameObject.transform.parent = null;
((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
Patch();
SceneManager.sceneLoaded += OnSceneLoaded;
Logger.LogInfo((object)$"{((BaseUnityPlugin)this).Info.Metadata.GUID} v{((BaseUnityPlugin)this).Info.Metadata.Version} has loaded!");
}
internal void Patch()
{
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Expected O, but got Unknown
//IL_0026: Expected O, but got Unknown
if (Harmony == null)
{
Harmony val = new Harmony(((BaseUnityPlugin)this).Info.Metadata.GUID);
Harmony val2 = val;
Harmony = val;
}
Harmony.PatchAll();
((MonoBehaviour)this).StartCoroutine(PeriodicValueCheck());
}
internal void Unpatch()
{
Harmony? harmony = Harmony;
if (harmony != null)
{
harmony.UnpatchSelf();
}
}
private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
{
sceneReady = true;
hasRevealedThisScene = false;
awaitingActiveExtraction = false;
}
internal void Update()
{
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Unknown result type (might be due to invalid IL or missing references)
if (!sceneReady || hasRevealedThisScene || !isHostOrSingleplayer || !EnableHotkeys.Value)
{
return;
}
KeyboardShortcut value = RevealKeybind.Value;
if ((int)((KeyboardShortcut)(ref value)).MainKey != 0)
{
value = RevealKeybind.Value;
if (((KeyboardShortcut)(ref value)).IsDown())
{
Logger.LogInfo((object)"Force reveal triggered by keybind");
ForceReveal();
}
}
}
[IteratorStateMachine(typeof(<PeriodicValueCheck>d__31))]
private IEnumerator PeriodicValueCheck()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <PeriodicValueCheck>d__31(0)
{
<>4__this = this
};
}
internal void ForceReveal()
{
if (hasRevealedThisScene)
{
return;
}
hasRevealedThisScene = true;
ValuableObject[] array = Object.FindObjectsOfType<ValuableObject>();
float num = array.Where((ValuableObject v) => !v.discovered).Sum((ValuableObject v) => v.dollarValueCurrent);
if (num == 0f)
{
num = previousRemainingValue;
}
ValuableObject[] array2 = array;
foreach (ValuableObject val in array2)
{
if (!val.discovered)
{
val.Discover((State)0);
}
}
if (NotificationSound.Value)
{
PlayNotificationSound();
}
ShowHaulMessage($"${Mathf.RoundToInt(num)} of Valuables Revealed!");
if (EnemiesRespond.Value)
{
AlertEnemies();
}
Logger.LogInfo((object)"Revealed valuables.");
}
public void PlayNotificationSound()
{
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
//IL_005a: Unknown result type (might be due to invalid IL or missing references)
//IL_0077: Unknown result type (might be due to invalid IL or missing references)
AudioClip val = ((IEnumerable<AudioClip>)Resources.FindObjectsOfTypeAll<AudioClip>()).FirstOrDefault((Func<AudioClip, bool>)((AudioClip c) => ((Object)c).name.Equals("valuable tracker target found")));
if ((Object)(object)val != (Object)null)
{
Vector3 val2 = (((Object)(object)Camera.main != (Object)null) ? ((Component)Camera.main).transform.position : Vector3.zero);
Logger.LogInfo((object)("Playing Audio: " + ((Object)val).name));
AudioSource.PlayClipAtPoint(val, val2);
}
else
{
Logger.LogWarning((object)"AudioClip 'valuable tracker target found' not found.");
}
}
private void ShowHaulMessage(string message, float duration = 2f)
{
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)HaulUI.instance == (Object)null)
{
Logger.LogWarning((object)"HaulUI.instance not found.");
return;
}
HaulUI instance = HaulUI.instance;
((Behaviour)instance).enabled = false;
object? value = AccessTools.Field(typeof(HaulUI), "Text").GetValue(instance);
TextMeshProUGUI val = (TextMeshProUGUI)((value is TextMeshProUGUI) ? value : null);
if ((Object)(object)val != (Object)null)
{
((TMP_Text)val).text = message;
}
((SemiUI)instance).SemiUITextFlashColor(Color.yellow, duration);
((SemiUI)instance).SemiUISpringShakeY(2f, 4f, 1f);
((MonoBehaviour)instance).StartCoroutine(EnableHaulUIAfterDelay(instance, duration));
}
[IteratorStateMachine(typeof(<EnableHaulUIAfterDelay>d__35))]
private IEnumerator EnableHaulUIAfterDelay(HaulUI ui, float delay)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <EnableHaulUIAfterDelay>d__35(0)
{
<>4__this = this,
ui = ui,
delay = delay
};
}
private void AlertEnemies()
{
//IL_0210: Unknown result type (might be due to invalid IL or missing references)
//IL_0215: Unknown result type (might be due to invalid IL or missing references)
//IL_0218: Unknown result type (might be due to invalid IL or missing references)
//IL_021d: Unknown result type (might be due to invalid IL or missing references)
//IL_0220: Unknown result type (might be due to invalid IL or missing references)
//IL_0225: Unknown result type (might be due to invalid IL or missing references)
//IL_0238: Unknown result type (might be due to invalid IL or missing references)
//IL_023a: Unknown result type (might be due to invalid IL or missing references)
//IL_0241: Unknown result type (might be due to invalid IL or missing references)
//IL_0246: Unknown result type (might be due to invalid IL or missing references)
//IL_024b: Unknown result type (might be due to invalid IL or missing references)
//IL_02ca: Unknown result type (might be due to invalid IL or missing references)
//IL_02e0: Unknown result type (might be due to invalid IL or missing references)
string text;
if (AlertDifficulty?.Value == "Dynamic")
{
string[] array = new string[5] { "None", "Investigate", "Sweep", "Purge", "Annihilation" };
text = array[SemiFunc.MoonLevel()];
}
else
{
text = AlertDifficulty?.Value;
}
if (text == "None")
{
Logger.LogInfo((object)"Moon Phase 0: Not alerting enemies");
return;
}
RoundDirector val = Object.FindObjectOfType<RoundDirector>();
if ((Object)(object)val == (Object)null)
{
Logger.LogWarning((object)"RoundDirector not found.");
return;
}
if (!val.extractionPointActive || (Object)(object)val.extractionPointCurrent == (Object)null)
{
Logger.LogInfo((object)"No active extraction point to alert enemies to. Awaiting activation");
awaitingActiveExtraction = true;
return;
}
EnemyDirector val2 = Object.FindObjectOfType<EnemyDirector>();
if ((Object)(object)val2 == (Object)null || val2.enemiesSpawned == null)
{
Logger.LogWarning((object)"EnemyDirector or enemiesSpawned list not found.");
return;
}
if (text == "Purge" || text == "Annihilation")
{
foreach (EnemyParent item in val2.enemiesSpawned)
{
if ((Object)(object)item != (Object)null && !item.Spawned)
{
item.Spawn();
if ((EnableLogging?.Value).Value)
{
Logger.LogInfo((object)("Respawned enemy: " + ((Object)item).name));
}
}
}
}
Transform transform = ((Component)val.extractionPointCurrent).transform;
Vector3 forward = transform.forward;
Vector3 right = transform.right;
Vector3 val3 = transform.position;
if (text != "Annihilation")
{
val3 += forward * 5f;
}
if (1 == 0)
{
}
float num = text switch
{
"Investigate" => 40f,
"Sweep" => 80f,
"Purge" => 200f,
"Annihilation" => 200f,
_ => 80f,
};
if (1 == 0)
{
}
float num2 = num;
bool flag = text == "Investigate";
val2.SetInvestigate(val3, num2, flag);
Logger.LogInfo((object)$"Alerted all enemies to investigate {val3}");
}
}
}
