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 REPOLib.Modules;
using RepoDice;
using UnityEngine;
[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: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.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 Durability
{
[BepInPlugin("ZeroTails.InitialValuables", "Initial Valuables", "1.0.0")]
public class InitialValuables : BaseUnityPlugin
{
private class ValuableDefinition
{
public string Name { get; }
public int SpawnCount { get; }
public float SpawnChance { get; }
public ValuableDefinition(string name, int spawnCount, float spawnChance)
{
Name = name;
SpawnCount = spawnCount;
SpawnChance = spawnChance;
}
}
[CompilerGenerated]
private sealed class <SpawnValuables>d__17 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
private GameObject <targetItem>5__1;
private Vector3 <itemPosition>5__2;
private float <currentYOffset>5__3;
private float <currentXOffset>5__4;
private List<ValuableDefinition>.Enumerator <>s__5;
private ValuableDefinition <valuable>5__6;
private int <i>5__7;
private float <randomValue>5__8;
private Vector3 <spawnPos>5__9;
private GameObject <spawnedValuable>5__10;
private List<ValuableDefinition>.Enumerator <>s__11;
private ValuableDefinition <valuable>5__12;
private int <i>5__13;
private float <randomValue>5__14;
private Vector3 <spawnPos>5__15;
private GameObject <spawnedValuable>5__16;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <SpawnValuables>d__17(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<targetItem>5__1 = null;
<>s__5 = default(List<ValuableDefinition>.Enumerator);
<valuable>5__6 = null;
<spawnedValuable>5__10 = null;
<>s__11 = default(List<ValuableDefinition>.Enumerator);
<valuable>5__12 = null;
<spawnedValuable>5__16 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0054: Unknown result type (might be due to invalid IL or missing references)
//IL_0059: Unknown result type (might be due to invalid IL or missing references)
//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
//IL_01df: Expected O, but got Unknown
//IL_0110: 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_012f: Unknown result type (might be due to invalid IL or missing references)
//IL_0141: Unknown result type (might be due to invalid IL or missing references)
//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
//IL_02c2: Unknown result type (might be due to invalid IL or missing references)
//IL_02d4: Unknown result type (might be due to invalid IL or missing references)
switch (<>1__state)
{
default:
return false;
case 0:
{
<>1__state = -1;
_isCoroutineRunning = true;
<targetItem>5__1 = FindTargetItem();
if ((Object)(object)<targetItem>5__1 != (Object)null)
{
<itemPosition>5__2 = <targetItem>5__1.transform.position;
<currentYOffset>5__3 = DefaultValuableYOffset;
<>s__5 = DefaultValuables.GetEnumerator();
try
{
while (<>s__5.MoveNext())
{
<valuable>5__6 = <>s__5.Current;
<i>5__7 = 0;
while (<i>5__7 < <valuable>5__6.SpawnCount)
{
<randomValue>5__8 = Random.Range(0f, 1f);
if (<randomValue>5__8 > <valuable>5__6.SpawnChance)
{
ManualLogSource? logger2 = _logger;
if (logger2 != null)
{
logger2.LogInfo((object)$"Skipping spawn of '{<valuable>5__6.Name}' due to spawn chance ({<randomValue>5__8} > {<valuable>5__6.SpawnChance}).");
}
}
else
{
<spawnPos>5__9 = <itemPosition>5__2 + new Vector3(0f, <currentYOffset>5__3, 0f);
<spawnedValuable>5__10 = SpawnValuable(<valuable>5__6.Name, <spawnPos>5__9);
<currentYOffset>5__3 += DefaultValuableYOffset;
<spawnedValuable>5__10 = null;
}
<i>5__7++;
}
<valuable>5__6 = null;
}
}
finally
{
((IDisposable)<>s__5).Dispose();
}
<>s__5 = default(List<ValuableDefinition>.Enumerator);
<>2__current = (object)new WaitForSeconds(1f);
<>1__state = 1;
return true;
}
ManualLogSource? logger3 = _logger;
if (logger3 != null)
{
logger3.LogWarning((object)"No target item found in the scene. Valuables will not spawn.");
}
break;
}
case 1:
<>1__state = -1;
<currentXOffset>5__4 = 0f;
<>s__11 = AdditionalValuables.GetEnumerator();
try
{
while (<>s__11.MoveNext())
{
<valuable>5__12 = <>s__11.Current;
<i>5__13 = 0;
while (<i>5__13 < <valuable>5__12.SpawnCount)
{
<randomValue>5__14 = Random.Range(0f, 1f);
if (<randomValue>5__14 > <valuable>5__12.SpawnChance)
{
ManualLogSource? logger = _logger;
if (logger != null)
{
logger.LogInfo((object)$"Skipping spawn of '{<valuable>5__12.Name}' due to spawn chance ({<randomValue>5__14} > {<valuable>5__12.SpawnChance}).");
}
}
else
{
<spawnPos>5__15 = <itemPosition>5__2 + new Vector3(<currentXOffset>5__4, AdditionalValuableYOffset, 0f);
<spawnedValuable>5__16 = SpawnValuable(<valuable>5__12.Name, <spawnPos>5__15);
<currentXOffset>5__4 += 0.5f;
<spawnedValuable>5__16 = null;
}
<i>5__13++;
}
<valuable>5__12 = null;
}
}
finally
{
((IDisposable)<>s__11).Dispose();
}
<>s__11 = default(List<ValuableDefinition>.Enumerator);
break;
}
_isCoroutineRunning = false;
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();
}
}
private static InitialValuables? _instance;
private static ManualLogSource? _logger;
private static bool _isCoroutineRunning = false;
private static bool _isPatched = false;
private static readonly float DefaultValuableYOffset = 0.5f;
private static readonly float AdditionalValuableYOffset = 1f;
private static readonly List<ValuableDefinition> DefaultValuables = new List<ValuableDefinition>();
private static readonly List<ValuableDefinition> AdditionalValuables = new List<ValuableDefinition>();
private ConfigEntry<string>? _userDefinedValuables;
private ConfigEntry<float>? _invincibilityDuration;
private readonly Dictionary<string, ConfigEntry<float>> _scaleModifiers = new Dictionary<string, ConfigEntry<float>>();
private readonly Dictionary<string, ConfigEntry<int>> _randomScaleOptions = new Dictionary<string, ConfigEntry<int>>();
private void Awake()
{
//IL_006c: Unknown result type (might be due to invalid IL or missing references)
//IL_0072: Expected O, but got Unknown
//IL_009a: Unknown result type (might be due to invalid IL or missing references)
//IL_00a7: Expected O, but got Unknown
if ((Object)(object)_instance != (Object)null)
{
Object.Destroy((Object)(object)this);
return;
}
_instance = this;
_logger = ((BaseUnityPlugin)this).Logger;
_invincibilityDuration = ((BaseUnityPlugin)this).Config.Bind<float>("Settings", "InvincibilityDuration", 5f, "Duration (in seconds) for which spawned valuables are invincible.");
InitializeValuables();
if (!_isPatched)
{
Harmony val = new Harmony("ZeroTails.InitialValuables");
val.Patch((MethodBase)AccessTools.Method(typeof(LoadingUI), "LevelAnimationStart", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(InitialValuables), "OnLevelStart", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
_isPatched = true;
}
}
private void InitializeValuables()
{
List<ValuableDefinition> list = new List<ValuableDefinition>
{
new ValuableDefinition("Gambler", 1, 1f),
new ValuableDefinition("Valuable Present Big (Chance)", 1, 1f),
new ValuableDefinition("Valuable Dummy Item Smith Note", 1, 0.1f)
};
foreach (ValuableDefinition item in list)
{
ConfigEntry<bool> val = ((BaseUnityPlugin)this).Config.Bind<bool>("Default Valuables", item.Name + " Active", true, "Enable or disable spawning of " + item.Name + ".");
ConfigEntry<int> val2 = ((BaseUnityPlugin)this).Config.Bind<int>("Default Valuables", item.Name + " Spawn Count", item.SpawnCount, "How many " + item.Name + " valuables to spawn per level.");
ConfigEntry<float> val3 = ((BaseUnityPlugin)this).Config.Bind<float>("Default Valuables", item.Name + " Spawn Chance", item.SpawnChance, "Chance for " + item.Name + " to spawn (1.0 = 100%, 0.5 = 50%, etc.).");
ConfigEntry<float> value = ((BaseUnityPlugin)this).Config.Bind<float>("Default Valuables", item.Name + " Scale Modifier", 1f, "Scale modifier for " + item.Name + " (1.0 = default size).");
ConfigEntry<int> value2 = ((BaseUnityPlugin)this).Config.Bind<int>("Default Valuables", item.Name + " Random Scale", 0, "Enable random scale for " + item.Name + " (0 = disabled, 1 = enabled).");
if (val.Value)
{
DefaultValuables.Add(new ValuableDefinition(item.Name, val2.Value, val3.Value));
_scaleModifiers[item.Name] = value;
_randomScaleOptions[item.Name] = value2;
}
}
_userDefinedValuables = ((BaseUnityPlugin)this).Config.Bind<string>("Valuables", "UserDefinedValuables", "", "Define your own valuables in the format: ValuableName:SpawnCount:SpawnChance:ScaleModifier:RandomScale, e.g., Valuable1:2:0.5:1.5:1,Valuable2:1:0.2:0.8:0");
if (!string.IsNullOrEmpty(_userDefinedValuables.Value))
{
ParseUserDefinedValuables(_userDefinedValuables.Value);
}
}
private void ParseUserDefinedValuables(string userDefinedValuables)
{
string[] array = userDefinedValuables.Split(',');
string[] array2 = array;
foreach (string text in array2)
{
string[] array3 = text.Split(':');
if (array3.Length != 5)
{
ManualLogSource? logger = _logger;
if (logger != null)
{
logger.LogWarning((object)("Invalid valuable definition: " + text + ". Expected format: ValuableName:SpawnCount:SpawnChance:ScaleModifier:RandomScale"));
}
continue;
}
string text2 = array3[0].Trim();
float result2;
float result3;
int result4;
if (!int.TryParse(array3[1], out var result) || result < 1)
{
ManualLogSource? logger2 = _logger;
if (logger2 != null)
{
logger2.LogWarning((object)("Invalid spawn count for valuable '" + text2 + "': " + array3[1] + ". Must be a positive integer."));
}
}
else if (!float.TryParse(array3[2], out result2) || result2 < 0f || result2 > 1f)
{
ManualLogSource? logger3 = _logger;
if (logger3 != null)
{
logger3.LogWarning((object)("Invalid spawn chance for valuable '" + text2 + "': " + array3[2] + ". Must be a float between 0.0 and 1.0."));
}
}
else if (!float.TryParse(array3[3], out result3) || result3 <= 0f)
{
ManualLogSource? logger4 = _logger;
if (logger4 != null)
{
logger4.LogWarning((object)("Invalid scale modifier for valuable '" + text2 + "': " + array3[3] + ". Must be a positive float."));
}
}
else if (!int.TryParse(array3[4], out result4) || (result4 != 0 && result4 != 1))
{
ManualLogSource? logger5 = _logger;
if (logger5 != null)
{
logger5.LogWarning((object)("Invalid random scale option for valuable '" + text2 + "': " + array3[4] + ". Must be 0 (disabled) or 1 (enabled)."));
}
}
else
{
AdditionalValuables.Add(new ValuableDefinition(text2, result, result2));
_scaleModifiers[text2] = ((BaseUnityPlugin)this).Config.Bind<float>("User Defined Valuables", text2 + " Scale Modifier", result3, "Scale modifier for " + text2 + " (1.0 = default size).");
_randomScaleOptions[text2] = ((BaseUnityPlugin)this).Config.Bind<int>("User Defined Valuables", text2 + " Random Scale", result4, "Enable random scale for " + text2 + " (0 = disabled, 1 = enabled).");
}
}
}
private static void OnLevelStart()
{
if (!PhotonNetwork.IsMasterClient)
{
return;
}
ClearPreviousState();
if (!_isCoroutineRunning)
{
InitialValuables? instance = _instance;
if (instance != null)
{
((MonoBehaviour)instance).StartCoroutine(SpawnValuables());
}
}
}
private static void ClearPreviousState()
{
InitialValuables? instance = _instance;
if (instance != null)
{
((MonoBehaviour)instance).StopAllCoroutines();
}
_isCoroutineRunning = false;
ManualLogSource? logger = _logger;
if (logger != null)
{
logger.LogInfo((object)"Cleared previous state and stopped all coroutines.");
}
}
[IteratorStateMachine(typeof(<SpawnValuables>d__17))]
private static IEnumerator SpawnValuables()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <SpawnValuables>d__17(0);
}
private static GameObject? FindTargetItem()
{
GameObject[] array = GameObject.FindGameObjectsWithTag("Cart");
GameObject[] array2 = array;
foreach (GameObject val in array2)
{
if (((Object)val).name == "In Cart")
{
return val;
}
}
return null;
}
private static GameObject? SpawnValuable(string valuableName, Vector3 spawnPos)
{
//IL_007b: Unknown result type (might be due to invalid IL or missing references)
//IL_007c: Unknown result type (might be due to invalid IL or missing references)
//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
//IL_00ab: 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)
//IL_0145: Unknown result type (might be due to invalid IL or missing references)
GameObject valuableByName = Misc.GetValuableByName(valuableName);
if ((Object)(object)valuableByName == (Object)null)
{
ManualLogSource? logger = _logger;
if (logger != null)
{
logger.LogError((object)("Could not find the valuable prefab for '" + valuableName + "'."));
}
return null;
}
string valuablePrefabPath = ResourcesHelper.GetValuablePrefabPath(valuableByName);
if (string.IsNullOrEmpty(valuablePrefabPath))
{
ManualLogSource? logger2 = _logger;
if (logger2 != null)
{
logger2.LogError((object)("Could not determine the prefab path for '" + valuableName + "'."));
}
return null;
}
GameObject val = PhotonNetwork.Instantiate(valuablePrefabPath, spawnPos, Quaternion.identity, (byte)0, (object[])null);
if ((Object)(object)val != (Object)null)
{
ManualLogSource? logger3 = _logger;
if (logger3 != null)
{
logger3.LogInfo((object)$"Successfully spawned '{valuableName}' at {spawnPos}.");
}
SetInvincibility(val);
float num = 1f;
InitialValuables? instance = _instance;
if (instance != null && instance._randomScaleOptions.TryGetValue(valuableName, out ConfigEntry<int> value) && value.Value == 1)
{
num = Random.Range(0.1f, 2f);
}
else
{
InitialValuables? instance2 = _instance;
if (instance2 != null && instance2._scaleModifiers.TryGetValue(valuableName, out ConfigEntry<float> value2))
{
num = value2.Value;
}
}
Transform transform = val.transform;
transform.localScale *= num;
PhotonView component = val.GetComponent<PhotonView>();
if ((Object)(object)component != (Object)null)
{
component.RPC("RPC_SetScale", (RpcTarget)1, new object[2]
{
((Object)val).name,
num
});
}
}
else
{
ManualLogSource? logger4 = _logger;
if (logger4 != null)
{
logger4.LogError((object)$"Failed to spawn '{valuableName}' at {spawnPos}.");
}
}
return val;
}
[PunRPC]
private void RPC_SetScale(string valuableName, float scaleModifier)
{
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
GameObject val = GameObject.Find(valuableName);
if ((Object)(object)val != (Object)null)
{
Transform transform = val.transform;
transform.localScale *= scaleModifier;
}
}
[PunRPC]
private void RPC_SetInvincibility(string valuableName, float duration)
{
GameObject val = GameObject.Find(valuableName);
if ((Object)(object)val != (Object)null)
{
SurplusValuable component = val.GetComponent<SurplusValuable>();
if ((Object)(object)component != (Object)null)
{
FieldInfo field = typeof(SurplusValuable).GetField("indestructibleTimer", BindingFlags.Instance | BindingFlags.NonPublic);
if (field != null)
{
field.SetValue(component, duration);
ManualLogSource? logger = _logger;
if (logger != null)
{
logger.LogInfo((object)$"[RPC] Set invincibility timer to {duration} seconds for '{((Object)val).name}'.");
}
}
else
{
ManualLogSource? logger2 = _logger;
if (logger2 != null)
{
logger2.LogError((object)("[RPC] Could not find 'indestructibleTimer' field on '" + ((Object)val).name + "'."));
}
}
}
else
{
ManualLogSource? logger3 = _logger;
if (logger3 != null)
{
logger3.LogWarning((object)("[RPC] No 'SurplusValuable' component found on '" + ((Object)val).name + "'."));
}
}
}
else
{
ManualLogSource? logger4 = _logger;
if (logger4 != null)
{
logger4.LogWarning((object)("[RPC] Could not find valuable '" + valuableName + "' to set invincibility."));
}
}
}
private static void SetInvincibility(GameObject valuable)
{
SurplusValuable component = valuable.GetComponent<SurplusValuable>();
if ((Object)(object)component == (Object)null)
{
ManualLogSource? logger = _logger;
if (logger != null)
{
logger.LogWarning((object)("No 'SurplusValuable' component found on spawned valuable '" + ((Object)valuable).name + "'."));
}
return;
}
FieldInfo field = typeof(SurplusValuable).GetField("indestructibleTimer", BindingFlags.Instance | BindingFlags.NonPublic);
if (field != null)
{
float valueOrDefault = (_instance?._invincibilityDuration?.Value).GetValueOrDefault(5f);
field.SetValue(component, valueOrDefault);
ManualLogSource? logger2 = _logger;
if (logger2 != null)
{
logger2.LogInfo((object)$"Set invincibility timer to {valueOrDefault} seconds for '{((Object)valuable).name}'.");
}
PhotonView component2 = valuable.GetComponent<PhotonView>();
if ((Object)(object)component2 != (Object)null)
{
component2.RPC("RPC_SetInvincibility", (RpcTarget)1, new object[2]
{
((Object)valuable).name,
valueOrDefault
});
}
}
else
{
ManualLogSource? logger3 = _logger;
if (logger3 != null)
{
logger3.LogError((object)("Could not find 'indestructibleTimer' field on '" + ((Object)valuable).name + "'."));
}
}
}
}
}
