using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using PerfectRandom.Sulfur.Core;
using PerfectRandom.Sulfur.Core.CharacterStats;
using PerfectRandom.Sulfur.Core.Items;
using PerfectRandom.Sulfur.Core.Stats;
using PerfectRandom.Sulfur.Core.UI;
using PerfectRandom.Sulfur.Core.UI.Inventory;
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(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("EnchantmentsUnbound")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+b30d3b45cbadd719ff2622c0f44f708547039289")]
[assembly: AssemblyProduct("EnchantmentsUnbound")]
[assembly: AssemblyTitle("EnchantmentsUnbound")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[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 EnchantmentsUnbound
{
public static class ModInfo
{
public const string Id = "lingyun67.enchantments_unbound";
public const string Name = "Enchantments Unbound";
public const string Version = "0.1.0";
}
[BepInPlugin("lingyun67.enchantments_unbound", "Enchantments Unbound", "0.1.0")]
public sealed class Plugin : BaseUnityPlugin
{
private Harmony harmony;
private void Awake()
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Expected O, but got Unknown
harmony = new Harmony("lingyun67.enchantments_unbound");
harmony.PatchAll();
((BaseUnityPlugin)this).Logger.LogInfo((object)"Enchantments Unbound loaded.");
}
private void OnDestroy()
{
if (harmony != null)
{
harmony.UnpatchSelf();
}
}
}
}
namespace EnchantmentsUnbound.Patches
{
[HarmonyPatch(typeof(InventoryItem))]
internal static class InventoryItemPatches
{
[HarmonyPatch("IsEnchantmentCompatible", new Type[] { typeof(EnchantmentDefinition) })]
[HarmonyPrefix]
private static bool IsEnchantmentCompatiblePrefix(InventoryItem __instance, EnchantmentDefinition enchantment, ref bool __result)
{
__result = (Object)(object)enchantment != (Object)null && __instance.HasFreeEnchantmentSlot;
return false;
}
[HarmonyPatch("GetRankLevelProgress")]
[HarmonyPrefix]
private static bool GetRankLevelProgressPrefix(InventoryItem __instance, ref float __result)
{
__result = CalculateUnlimitedRankProgress(__instance.GetExperience());
return false;
}
[HarmonyPatch("AddEnchantment")]
[HarmonyPrefix]
private static bool AddEnchantmentPrefix(InventoryItem __instance, ItemDefinition enchantmentItem, bool announce)
{
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
//IL_00af: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)enchantmentItem == (Object)null || !((EnchantmentId)(ref enchantmentItem.appliesEnchantment)).IsValid)
{
Debug.LogError((object)"Trying to add invalid enchantment item.");
return false;
}
EnchantmentDefinition asset = AssetAccess.GetAsset(enchantmentItem.appliesEnchantment);
if ((Object)(object)asset == (Object)null)
{
Debug.LogError((object)"Trying to add null enchantment.");
return false;
}
asset.RegisterAppliedBy(enchantmentItem);
__instance.enchantments.Add(asset);
StaticInstance<AchievementManager>.Instance.EnchantmentAppliedToItem(asset, __instance.itemDefinition, __instance.enchantments.Count);
if (HasRandomOilAttribute(asset))
{
for (int i = 0; i < asset.modifiersApplied.Count; i++)
{
AddRandomOilAttributes(__instance, asset.modifiersApplied[i].attribute, asset);
}
}
else
{
AddEnchantmentModifiers(__instance, asset, GlobalId.op_Implicit(((EnchantmentId)(ref asset.id)).AsGlobalId()));
}
if (announce)
{
StaticInstance<SoundBankUI>.Instance.PlayClip((UISounds)6);
}
__instance.SyncWithInstancedVersion();
return false;
}
private static float CalculateUnlimitedRankProgress(float experience)
{
if (experience <= 0f)
{
return 0f;
}
float num = 0f;
float num2 = 50f;
int num3 = 0;
while (experience >= num2 && num3 < 200)
{
num3++;
num = num2;
num2 *= 2.5f;
}
if (num2 <= num)
{
return num3;
}
return (float)num3 + (experience - num) / (num2 - num);
}
private static bool HasRandomOilAttribute(EnchantmentDefinition enchantment)
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: Invalid comparison between Unknown and I4
if (enchantment.modifiersApplied == null)
{
return false;
}
for (int i = 0; i < enchantment.modifiersApplied.Count; i++)
{
if ((int)enchantment.modifiersApplied[i].attribute == 84)
{
return true;
}
}
return false;
}
private static void AddRandomOilAttributes(InventoryItem inventoryItem, ItemAttributes attribute, EnchantmentDefinition randomOilEnchantment)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0004: Invalid comparison between Unknown and I4
//IL_009c: Unknown result type (might be due to invalid IL or missing references)
//IL_0139: 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)
//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
if ((int)attribute != 84)
{
return;
}
inventoryItem.enchantments.Remove(randomOilEnchantment);
ItemDefinition val = null;
EnchantmentDefinition val2 = null;
LootTable enchantmentOilLootTable = StaticInstance<GameManager>.Instance.Settings.LootSettings.enchantmentOilLootTable;
if ((Object)(object)enchantmentOilLootTable == (Object)null || enchantmentOilLootTable.entries == null)
{
return;
}
bool flag = false;
int count = enchantmentOilLootTable.entries.Count;
for (int i = 0; i < count; i++)
{
val = enchantmentOilLootTable.SelectOneItem();
if (!((Object)(object)val == (Object)null) && ((EnchantmentId)(ref val.appliesEnchantment)).IsValid)
{
val2 = AssetAccess.GetAsset(val.appliesEnchantment);
if ((Object)(object)val2 != (Object)null && val2.modifiersApplied != null && randomOilEnchantment.id != val.appliesEnchantment && val2.modifiersApplied.Count > 0)
{
flag = true;
break;
}
}
}
if (flag && !((Object)(object)val == (Object)null) && !((Object)(object)val2 == (Object)null))
{
val2.RegisterAppliedBy(val);
inventoryItem.enchantments.Add(val2);
AddEnchantmentModifiers(inventoryItem, val2, GlobalId.op_Implicit(((EnchantmentId)(ref val.appliesEnchantment)).AsGlobalId()));
}
}
private static void AddEnchantmentModifiers(InventoryItem inventoryItem, EnchantmentDefinition enchantment, uint sourceId)
{
//IL_002a: 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_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_0046: Expected O, but got Unknown
if (enchantment.modifiersApplied != null)
{
for (int i = 0; i < enchantment.modifiersApplied.Count; i++)
{
ItemModifierContainer val = enchantment.modifiersApplied[i];
inventoryItem.stats.AddModifier(val.attribute, new StatModifier(val.value, val.modType, sourceId));
}
}
}
}
[HarmonyPatch(typeof(Paperdoll), "GetItemsCompatibleWithEnchantment")]
internal static class PaperdollEnchantmentHighlightPatch
{
private static bool Prefix(Paperdoll __instance, EnchantmentDefinition enchantment, ref List<InventoryItem> __result)
{
List<InventoryItem> list = new List<InventoryItem>();
List<PaperdollSlot> slots = __instance.GetSlots();
for (int i = 0; i < slots.Count; i++)
{
InventoryItem itemInSlot = slots[i].itemInSlot;
if ((Object)(object)itemInSlot != (Object)null && itemInSlot.IsEnchantmentCompatible(enchantment))
{
list.Add(itemInSlot);
}
}
__result = list;
return false;
}
}
[HarmonyPatch(typeof(ItemGrid), "GetItemsCompatibleWithEnchantment")]
internal static class ItemGridEnchantmentHighlightPatch
{
private static bool Prefix(ItemGrid __instance, EnchantmentDefinition enchantment, ref List<InventoryItem> __result)
{
List<InventoryItem> list = new List<InventoryItem>();
GridSlot[,] slots = __instance.Slots;
int upperBound = slots.GetUpperBound(0);
int upperBound2 = slots.GetUpperBound(1);
for (int i = slots.GetLowerBound(0); i <= upperBound; i++)
{
for (int j = slots.GetLowerBound(1); j <= upperBound2; j++)
{
InventoryItem itemInSlot = slots[i, j].ItemInSlot;
if ((Object)(object)itemInSlot != (Object)null && itemInSlot.IsEnchantmentCompatible(enchantment) && !list.Contains(itemInSlot))
{
list.Add(itemInSlot);
}
}
}
if ((Object)(object)StaticInstance<UIManager>.Instance != (Object)null && (Object)(object)StaticInstance<UIManager>.Instance.Paperdoll != (Object)null)
{
list.AddRange(StaticInstance<UIManager>.Instance.Paperdoll.GetItemsCompatibleWithEnchantment(enchantment));
}
__result = list;
return false;
}
}
}
