using System;
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.Logging;
using Microsoft.CodeAnalysis;
using Mono.Cecil;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using MonoMod.RuntimeDetour;
using R2API;
using R2API.Utils;
using RoR2;
using UnityEngine;
using UnityEngine.AddressableAssets;
using itsschwer.Items.Helpers;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("itsschwer.Items")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.1.0.0")]
[assembly: AssemblyInformationalVersion("1.1.0+8f54b236291b87a4c46452df9754d54fd5af77e0")]
[assembly: AssemblyProduct("itsschwer.Items")]
[assembly: AssemblyTitle("itsschwer.Items")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.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.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace itsschwer.Items
{
internal static class MendConsumed
{
[Serializable]
[CompilerGenerated]
private sealed class <>c
{
public static readonly <>c <>9 = new <>c();
public static Func<Instruction, bool> <>9__3_2;
public static Func<Instruction, bool> <>9__3_3;
public static Func<Instruction, bool> <>9__3_4;
public static Func<Instruction, bool> <>9__3_6;
public static Func<Instruction, bool> <>9__3_7;
public static Func<Instruction, bool> <>9__3_9;
public static Manipulator <>9__3_0;
internal void <ApplyIL>b__3_0(ILContext il)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: Expected O, but got Unknown
//IL_013d: Unknown result type (might be due to invalid IL or missing references)
//IL_0154: Unknown result type (might be due to invalid IL or missing references)
//IL_0171: Unknown result type (might be due to invalid IL or missing references)
//IL_0193: Unknown result type (might be due to invalid IL or missing references)
//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
//IL_01cc: 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)
//IL_0200: Unknown result type (might be due to invalid IL or missing references)
<>c__DisplayClass3_0 CS$<>8__locals0 = new <>c__DisplayClass3_0();
ILCursor val = new ILCursor(il);
CS$<>8__locals0.funcInvoke = null;
CS$<>8__locals0.nextElseIf = null;
CS$<>8__locals0.ctorFunc = null;
FieldReference val3 = default(FieldReference);
MethodReference val2 = default(MethodReference);
Func<Instruction, bool>[] array = new Func<Instruction, bool>[9]
{
(Instruction x) => ILPatternMatchingExt.MatchBr(x, ref CS$<>8__locals0.funcInvoke),
(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 1),
(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, ref val3),
(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<Object>(x, "op_Equality"),
(Instruction x) => ILPatternMatchingExt.MatchBrfalse(x, ref CS$<>8__locals0.nextElseIf),
(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
(Instruction x) => ILPatternMatchingExt.MatchLdftn(x, ref val2),
(Instruction x) => ILPatternMatchingExt.MatchNewobj(x, ref CS$<>8__locals0.ctorFunc),
(Instruction x) => ILPatternMatchingExt.MatchStloc(x, 0)
};
if (val.TryGotoNext((MoveType)2, array))
{
Instruction target = CS$<>8__locals0.nextElseIf.Target;
try
{
val.Emit(OpCodes.Br, CS$<>8__locals0.funcInvoke.Target);
val.Emit(OpCodes.Ldarg_1);
CS$<>8__locals0.nextElseIf.Target = val.Previous;
val.Emit(OpCodes.Ldsfld, typeof(MendConsumed).GetField("equipmentDef", BindingFlags.Static | BindingFlags.Public));
val.Emit(OpCodes.Call, (MethodBase)typeof(Object).GetMethod("op_Equality"));
val.Emit(OpCodes.Brfalse, target);
val.Emit(OpCodes.Ldarg_0);
val.Emit(OpCodes.Ldftn, (MethodBase)typeof(MendConsumed).GetMethod("Execute", BindingFlags.Static | BindingFlags.NonPublic));
val.Emit(OpCodes.Newobj, CS$<>8__locals0.ctorFunc);
val.Emit(OpCodes.Stloc_0);
return;
}
catch (Exception ex)
{
Plugin.Logger.LogError((object)ex);
return;
}
}
Plugin.Logger.LogError((object)"MendConsumed> Cannot hook: failed to match IL instructions.");
}
internal bool <ApplyIL>b__3_2(Instruction x)
{
return ILPatternMatchingExt.MatchLdarg(x, 1);
}
internal bool <ApplyIL>b__3_3(Instruction x)
{
FieldReference val = default(FieldReference);
return ILPatternMatchingExt.MatchLdsfld(x, ref val);
}
internal bool <ApplyIL>b__3_4(Instruction x)
{
return ILPatternMatchingExt.MatchCallOrCallvirt<Object>(x, "op_Equality");
}
internal bool <ApplyIL>b__3_6(Instruction x)
{
return ILPatternMatchingExt.MatchLdarg(x, 0);
}
internal bool <ApplyIL>b__3_7(Instruction x)
{
MethodReference val = default(MethodReference);
return ILPatternMatchingExt.MatchLdftn(x, ref val);
}
internal bool <ApplyIL>b__3_9(Instruction x)
{
return ILPatternMatchingExt.MatchStloc(x, 0);
}
}
[CompilerGenerated]
private sealed class <>c__DisplayClass3_0
{
public ILLabel funcInvoke;
public ILLabel nextElseIf;
public MethodReference ctorFunc;
internal bool <ApplyIL>b__1(Instruction x)
{
return ILPatternMatchingExt.MatchBr(x, ref funcInvoke);
}
internal bool <ApplyIL>b__5(Instruction x)
{
return ILPatternMatchingExt.MatchBrfalse(x, ref nextElseIf);
}
internal bool <ApplyIL>b__8(Instruction x)
{
return ILPatternMatchingExt.MatchNewobj(x, ref ctorFunc);
}
}
public static readonly EquipmentDef equipmentDef;
internal static void Init()
{
Plugin.Logger.LogDebug((object)("Added equipment " + ((Object)equipmentDef).name + " (" + Language.GetString(equipmentDef.nameToken) + ")"));
}
static MendConsumed()
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_00a2: 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_00be: 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_0106: Unknown result type (might be due to invalid IL or missing references)
//IL_0110: Expected O, but got Unknown
equipmentDef = Object.Instantiate<EquipmentDef>(Addressables.LoadAssetAsync<EquipmentDef>((object)"RoR2/DLC1/BossHunter/BossHunter.asset").WaitForCompletion());
((Object)equipmentDef).name = "itsschwer_MendConsumed";
string text = "itsschwer".ToUpperInvariant() + "_" + "MendConsumed".ToUpperInvariant();
equipmentDef.nameToken = text + "_NAME";
equipmentDef.pickupToken = text + "_PICKUP";
equipmentDef.descriptionToken = text + "_DESC";
equipmentDef.loreToken = "- no lore -";
equipmentDef.pickupIconSprite = Addressables.LoadAssetAsync<Sprite>((object)"RoR2/DLC1/LunarWings/texLunarWingsIcon.png").WaitForCompletion();
equipmentDef.pickupModelPrefab = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC1/LunarWings/PickupLunarWings.prefab").WaitForCompletion();
equipmentDef.equipmentIndex = (EquipmentIndex)(-1);
equipmentDef.requiredExpansion = null;
equipmentDef.unlockableDef = null;
equipmentDef.cooldown = 15f;
ItemAPI.Add(new CustomEquipment(equipmentDef, (ItemDisplayRule[])null));
LanguageAPI.Add(equipmentDef.nameToken, "Replenisher");
LanguageAPI.Add(equipmentDef.pickupToken, "Restores broken, consumed, and empty items. Transforms on use.");
LanguageAPI.Add(equipmentDef.descriptionToken, "<style=cIsUtility>Restores</style> broken, consumed, and empty items back into their <style=cIsDamage>original forms</style>. Does not affect items that can regenerate. Equipment <style=cIsUtility>transforms</style> into a <style=cIsDamage>random equipment</style> when depleted.");
ApplyIL();
}
private static void ApplyIL()
{
//IL_0035: 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_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: Expected O, but got Unknown
MethodInfo? method = typeof(EquipmentSlot).GetMethod("PerformEquipmentAction", BindingFlags.Instance | BindingFlags.NonPublic);
object obj = <>c.<>9__3_0;
if (obj == null)
{
Manipulator val = delegate(ILContext il)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: Expected O, but got Unknown
//IL_013d: Unknown result type (might be due to invalid IL or missing references)
//IL_0154: Unknown result type (might be due to invalid IL or missing references)
//IL_0171: Unknown result type (might be due to invalid IL or missing references)
//IL_0193: Unknown result type (might be due to invalid IL or missing references)
//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
//IL_01cc: 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)
//IL_0200: Unknown result type (might be due to invalid IL or missing references)
ILCursor val2 = new ILCursor(il);
ILLabel funcInvoke = null;
ILLabel nextElseIf = null;
MethodReference ctorFunc = null;
FieldReference val4 = default(FieldReference);
MethodReference val3 = default(MethodReference);
Func<Instruction, bool>[] array = new Func<Instruction, bool>[9]
{
(Instruction x) => ILPatternMatchingExt.MatchBr(x, ref funcInvoke),
(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 1),
(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, ref val4),
(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<Object>(x, "op_Equality"),
(Instruction x) => ILPatternMatchingExt.MatchBrfalse(x, ref nextElseIf),
(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
(Instruction x) => ILPatternMatchingExt.MatchLdftn(x, ref val3),
(Instruction x) => ILPatternMatchingExt.MatchNewobj(x, ref ctorFunc),
(Instruction x) => ILPatternMatchingExt.MatchStloc(x, 0)
};
if (val2.TryGotoNext((MoveType)2, array))
{
Instruction target = nextElseIf.Target;
try
{
val2.Emit(OpCodes.Br, funcInvoke.Target);
val2.Emit(OpCodes.Ldarg_1);
nextElseIf.Target = val2.Previous;
val2.Emit(OpCodes.Ldsfld, typeof(MendConsumed).GetField("equipmentDef", BindingFlags.Static | BindingFlags.Public));
val2.Emit(OpCodes.Call, (MethodBase)typeof(Object).GetMethod("op_Equality"));
val2.Emit(OpCodes.Brfalse, target);
val2.Emit(OpCodes.Ldarg_0);
val2.Emit(OpCodes.Ldftn, (MethodBase)typeof(MendConsumed).GetMethod("Execute", BindingFlags.Static | BindingFlags.NonPublic));
val2.Emit(OpCodes.Newobj, ctorFunc);
val2.Emit(OpCodes.Stloc_0);
return;
}
catch (Exception ex)
{
Plugin.Logger.LogError((object)ex);
return;
}
}
Plugin.Logger.LogError((object)"MendConsumed> Cannot hook: failed to match IL instructions.");
};
<>c.<>9__3_0 = val;
obj = (object)val;
}
new ILHook((MethodBase)method, (Manipulator)obj);
}
private static bool Execute(this EquipmentSlot equipmentSlot)
{
//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
//IL_00bc: Expected O, but got Unknown
//IL_0045: 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_005b: 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)
//IL_0077: Unknown result type (might be due to invalid IL or missing references)
//IL_0089: Unknown result type (might be due to invalid IL or missing references)
CharacterBody characterBody = equipmentSlot.characterBody;
Inventory val = ((characterBody != null) ? characterBody.inventory : null);
if (!Object.op_Implicit((Object)(object)val))
{
return false;
}
if (equipmentSlot.stock <= 1)
{
PickupDef pickupDef = PickupCatalog.GetPickupDef(Run.instance.availableEquipmentDropList[Random.Range(0, Run.instance.availableEquipmentDropList.Count)]);
EquipmentIndex val2 = (EquipmentIndex)((pickupDef == null) ? (-1) : ((int)pickupDef.equipmentIndex));
CharacterMasterNotificationQueue.SendTransformNotification(equipmentSlot.characterBody.master, equipmentSlot.characterBody.inventory.currentEquipmentIndex, val2, (TransformationType)0);
equipmentSlot.characterBody.inventory.SetEquipmentIndex(val2);
}
RestoreConsumedItems(val, equipmentSlot.characterBody.master);
EffectData val3 = new EffectData
{
origin = equipmentSlot.characterBody.transform.position
};
val3.SetNetworkedObjectReference(((Component)equipmentSlot.characterBody).gameObject);
EffectManager.SpawnEffect(LegacyResourcesAPI.Load<GameObject>("Prefabs/Effects/HealingPotionEffect"), val3, true);
EffectManager.SpawnEffect(LegacyResourcesAPI.Load<GameObject>("Prefabs/Effects/ImpactEffects/DelicateWatchProcEffect"), val3, true);
return true;
}
private static void RestoreConsumedItems(Inventory inventory, CharacterMaster notificationTarget)
{
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: Unknown result type (might be due to invalid IL or missing references)
(ItemDef, ItemDef)[] transformations = MendConsumedTransformations.GetTransformations(inventory);
for (int i = 0; i < transformations.Length; i++)
{
int itemCount = inventory.GetItemCount(transformations[i].Item1);
inventory.RemoveItem(transformations[i].Item1, itemCount);
if (Object.op_Implicit((Object)(object)transformations[i].Item2))
{
inventory.GiveItem(transformations[i].Item2, itemCount);
if (itemCount > 0)
{
CharacterMasterNotificationQueue.SendTransformNotification(notificationTarget, transformations[i].Item1.itemIndex, transformations[i].Item2.itemIndex, (TransformationType)0);
}
}
}
}
}
public static class MendConsumedTransformations
{
private static List<IReplenishTransformation> transformations = new List<IReplenishTransformation>();
internal static void Init()
{
List<IReplenishTransformation> list = new List<IReplenishTransformation>(5);
list.Add(new ReplenishTransformation(Items.ExtraLifeConsumed, Items.ExtraLife));
list.Add(new ConditionalReplenishTransformation(Items.ExtraLifeVoidConsumed, Items.ExtraLifeVoid, Items.ExtraLife, (Inventory inventory) => inventory.GetItemCount(Items.ExtraLifeConsumed) > 0));
list.Add(new ReplenishTransformation(Items.FragileDamageBonusConsumed, Items.FragileDamageBonus));
list.Add(new ReplenishTransformation(Items.HealingPotionConsumed, Items.HealingPotion));
list.Add(new ReplenishTransformation(Items.TonicAffliction, null));
list.AddRange(transformations);
transformations = list;
}
public static (ItemDef consumed, ItemDef original)[] GetTransformations(Inventory inventory)
{
(ItemDef, ItemDef)[] array = new(ItemDef, ItemDef)[transformations.Count];
for (int i = 0; i < transformations.Count; i++)
{
array[i] = (transformations[i].Consumed, transformations[i].GetTransformation(inventory));
}
return array;
}
public static bool Register(IReplenishTransformation transformation)
{
if (transformation == null || (Object)(object)transformation.Consumed == (Object)null)
{
return false;
}
for (int i = 0; i < transformations.Count; i++)
{
if ((Object)(object)transformations[i].Consumed == (Object)(object)transformation.Consumed)
{
Plugin.Logger.LogWarning((object)(transformation.Consumed.nameToken + " already has an IReplenishTransformation, skipping transformation from " + GetExecutingMethod()));
return false;
}
}
transformations.Add(transformation);
return true;
}
private static string GetExecutingMethod(int index = 0)
{
MethodBase method = new StackTrace().GetFrame(index + 3).GetMethod();
return $"{method.DeclaringType}::{method.Name}";
}
}
[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInPlugin("itsschwer.Items", "itsschwer.Items", "1.1.0")]
public sealed class Plugin : BaseUnityPlugin
{
public const string GUID = "itsschwer.Items";
public const string Author = "itsschwer";
public const string Name = "items_from_itsschwer";
public const string Version = "1.1.0";
internal static ManualLogSource Logger { get; private set; }
private void Awake()
{
Logger = ((BaseUnityPlugin)this).Logger;
MendConsumed.Init();
RoR2Application.onLoad = (Action)Delegate.Combine(RoR2Application.onLoad, new Action(MendConsumedTransformations.Init));
Logger.LogMessage((object)"~awake.");
}
}
}
namespace itsschwer.Items.Helpers
{
public class ConditionalReplenishTransformation : IReplenishTransformation
{
private readonly ItemDef consumed;
private readonly ItemDef original;
private readonly ItemDef conditional;
private readonly Func<Inventory, bool> condition;
public ItemDef Consumed => consumed;
public ConditionalReplenishTransformation(ItemDef consumed, ItemDef original, ItemDef conditional, Func<Inventory, bool> condition)
{
this.consumed = consumed;
this.original = original;
this.conditional = conditional;
this.condition = condition;
}
public ItemDef GetTransformation(Inventory inventory)
{
if (!condition(inventory))
{
return original;
}
return conditional;
}
}
public interface IReplenishTransformation
{
ItemDef Consumed { get; }
ItemDef GetTransformation(Inventory inventory);
}
public class ReplenishTransformation : IReplenishTransformation
{
private readonly ItemDef consumed;
private readonly ItemDef original;
public ItemDef Consumed => consumed;
public ReplenishTransformation(ItemDef consumed, ItemDef original)
{
this.consumed = consumed;
this.original = original;
}
public ItemDef GetTransformation(Inventory inventory)
{
return original;
}
}
}
