using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
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.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using REPOLib.Modules;
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: IgnoresAccessChecksTo("")]
[assembly: AssemblyCompany("Snicki")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("CustomCarts")]
[assembly: AssemblyTitle("CustomCarts")]
[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 CustomCarts
{
[BepInPlugin("Snicki.CustomCarts", "CustomCarts", "1.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class CustomCarts : BaseUnityPlugin
{
public static Durability WeakDurability = ScriptableObject.CreateInstance<Durability>();
public bool IsLoaded = false;
public Dictionary<PhysGrabCart, List<PhysGrabObject>> cartItems = new Dictionary<PhysGrabCart, List<PhysGrabObject>>();
internal static CustomCarts Instance { get; private set; } = null;
internal static ManualLogSource Logger => Instance._logger;
private ManualLogSource _logger => ((BaseUnityPlugin)this).Logger;
internal Harmony? Harmony { get; set; }
public static Durability InvincibleDurability { get; set; }
private void Awake()
{
Instance = this;
((Component)this).gameObject.transform.parent = null;
((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
Patch();
string directoryName = Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location);
string text = Path.Combine(directoryName, "CustomCarts");
AssetBundle assetBundle = AssetBundle.LoadFromFile(text);
LoadAssets(assetBundle);
Logger.LogInfo((object)$"{((BaseUnityPlugin)this).Info.Metadata.GUID} v{((BaseUnityPlugin)this).Info.Metadata.Version} has loaded!");
WeakDurability.durability = 0f;
WeakDurability.fragility = 100f;
IsLoaded = true;
}
private void LoadAssets(AssetBundle assetBundle)
{
Item val = assetBundle.LoadAsset<Item>("Item Cart Small Orbs");
val.prefab = assetBundle.LoadAsset<GameObject>("Item Cart Small Orbs");
Items.RegisterItem(val);
Item val2 = assetBundle.LoadAsset<Item>("Item Cart Medium Orbs");
val2.prefab = assetBundle.LoadAsset<GameObject>("Item Cart Medium Orbs");
Items.RegisterItem(val2);
InvincibleDurability = assetBundle.LoadAsset<Durability>("Durability Invincible");
Logger.LogDebug((object)("Item Name => " + ((Object)val).name));
}
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();
}
internal void Unpatch()
{
Harmony? harmony = Harmony;
if (harmony != null)
{
harmony.UnpatchSelf();
}
}
private void Update()
{
}
}
[HarmonyPatch(typeof(PhysGrabCart))]
public class PhysGrabCartPatch
{
[HarmonyPostfix]
[HarmonyPatch("ObjectsInCart")]
private static void ObjectsInCart(PhysGrabCart __instance, List<PhysGrabObject> ___itemsInCart)
{
if (CustomCarts.Instance.IsLoaded && ((Object)__instance).name.Contains("Orb"))
{
if (CustomCarts.Instance.cartItems.TryGetValue(__instance, out List<PhysGrabObject> _))
{
CustomCarts.Instance.cartItems.Remove(__instance);
}
CustomCarts.Instance.cartItems.Add(__instance, ___itemsInCart);
}
}
}
[HarmonyPatch(typeof(PhysGrabObject))]
internal class PhysGrabObjectPatch
{
[CompilerGenerated]
private sealed class <ExpandItem>d__6 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
private float <duration>5__1;
private float <time>5__2;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <ExpandItem>d__6(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0093: 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_00b9: Unknown result type (might be due to invalid IL or missing references)
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<duration>5__1 = 0.5f;
<time>5__2 = 0f;
goto IL_00dc;
case 1:
<>1__state = -1;
goto IL_00dc;
case 2:
{
<>1__state = -1;
return false;
}
IL_00dc:
if (<time>5__2 < <duration>5__1)
{
<time>5__2 += Time.deltaTime;
CustomCarts.Logger.LogDebug((object)<time>5__2);
((Component)instance).gameObject.transform.localScale = Vector3.Lerp(((Component)instance).gameObject.transform.localScale, new Vector3(1f, 1f, 1f), <time>5__2 / <duration>5__1);
<>2__current = null;
<>1__state = 1;
return true;
}
<>2__current = null;
<>1__state = 2;
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();
}
}
[CompilerGenerated]
private sealed class <ShrinkItem>d__5 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
private float <duration>5__1;
private float <time>5__2;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <ShrinkItem>d__5(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0093: 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_00b9: Unknown result type (might be due to invalid IL or missing references)
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<duration>5__1 = 0.5f;
<time>5__2 = 0f;
goto IL_00dc;
case 1:
<>1__state = -1;
goto IL_00dc;
case 2:
{
<>1__state = -1;
return false;
}
IL_00dc:
if (<time>5__2 < <duration>5__1)
{
<time>5__2 += Time.deltaTime;
CustomCarts.Logger.LogDebug((object)<time>5__2);
((Component)instance).gameObject.transform.localScale = Vector3.Lerp(((Component)instance).gameObject.transform.localScale, new Vector3(0.5f, 0.5f, 0.5f), <time>5__2 / <duration>5__1);
<>2__current = null;
<>1__state = 1;
return true;
}
<>2__current = null;
<>1__state = 2;
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 static float transformSize = 1f;
private static PhysGrabObject instance;
private static Dictionary<PhysGrabObject, Coroutine> shrinkRoutines = new Dictionary<PhysGrabObject, Coroutine>();
private static Dictionary<PhysGrabObject, Coroutine> expandRoutines = new Dictionary<PhysGrabObject, Coroutine>();
[HarmonyPatch("Update")]
[HarmonyPostfix]
private static void Update(PhysGrabObject __instance, bool ___isValuable)
{
//IL_0163: Unknown result type (might be due to invalid IL or missing references)
//IL_0172: Unknown result type (might be due to invalid IL or missing references)
//IL_0177: Unknown result type (might be due to invalid IL or missing references)
if (!CustomCarts.Instance.IsLoaded)
{
return;
}
foreach (KeyValuePair<PhysGrabCart, List<PhysGrabObject>> cartItem in CustomCarts.Instance.cartItems)
{
if (!((Object)cartItem.Key).name.Contains("Orb") || !((Object)__instance).name.Contains("Enemy Valuable"))
{
continue;
}
instance = __instance;
if (cartItem.Value.Any((PhysGrabObject x) => (Object)(object)x == (Object)(object)__instance))
{
if (!shrinkRoutines.Keys.Contains(__instance))
{
if (expandRoutines.Keys.Contains(__instance))
{
expandRoutines.Remove(__instance);
}
transformSize = 1f;
shrinkRoutines.Add(__instance, ((MonoBehaviour)__instance).StartCoroutine(ShrinkItem()));
ValuableObject component = ((Component)__instance).GetComponent<ValuableObject>();
component.durabilityPreset = CustomCarts.InvincibleDurability;
Transform transform = ((Component)cartItem.Key).transform;
transform.localPosition += new Vector3(3f, 2f);
}
}
else if (!expandRoutines.Keys.Contains(__instance))
{
if (shrinkRoutines.Keys.Contains(__instance))
{
((MonoBehaviour)__instance).StopCoroutine(GeneralExtensions.GetValueSafe<PhysGrabObject, Coroutine>(shrinkRoutines, __instance));
shrinkRoutines.Remove(__instance);
}
expandRoutines.Add(__instance, ((MonoBehaviour)__instance).StartCoroutine(ExpandItem()));
ValuableObject val = null;
if (((Component)__instance).TryGetComponent<ValuableObject>(ref val))
{
val.durabilityPreset = CustomCarts.WeakDurability;
}
}
}
}
[IteratorStateMachine(typeof(<ShrinkItem>d__5))]
private static IEnumerator ShrinkItem()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <ShrinkItem>d__5(0);
}
[IteratorStateMachine(typeof(<ExpandItem>d__6))]
private static IEnumerator ExpandItem()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <ExpandItem>d__6(0);
}
}
}
