using System;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using Microsoft.CodeAnalysis;
using On.RoR2;
using R2API;
using RoR2;
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: AssemblyCompany("ExponentialItemsReloaded")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("ExponentialItemsReloaded")]
[assembly: AssemblyTitle("ExponentialItemsReloaded")]
[assembly: AssemblyVersion("1.0.0.0")]
[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 ExponentialItemsReloaded
{
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInPlugin("com.bentley.exponentialitemsreloaded", "ExponentialItemsReloaded", "1.0.0")]
public class ExponentialItemsReloadedPlugin : BaseUnityPlugin
{
public const string PluginGUID = "com.bentley.exponentialitemsreloaded";
public const string PluginName = "ExponentialItemsReloaded";
public const string PluginVersion = "1.0.0";
private static ArtifactDef exponentialArtifactDef;
private static ConfigEntry<int> maxStack;
private static ConfigEntry<int> baseSize;
private static ConfigEntry<bool> affectTierless;
private static ConfigEntry<bool> affectEquipment;
private static bool suppressExponentialHook;
private Sprite LoadSprite(string fileName)
{
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_0051: Expected O, but got Unknown
//IL_0072: Unknown result type (might be due to invalid IL or missing references)
//IL_0081: Unknown result type (might be due to invalid IL or missing references)
string text = Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location), fileName);
if (!File.Exists(text))
{
((BaseUnityPlugin)this).Logger.LogError((object)("Icon file not found: " + text));
return null;
}
byte[] array = File.ReadAllBytes(text);
Texture2D val = new Texture2D(2, 2);
ImageConversion.LoadImage(val, array);
return Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f));
}
public void Awake()
{
//IL_0093: Unknown result type (might be due to invalid IL or missing references)
//IL_009d: Expected O, but got Unknown
//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
//IL_00af: Expected O, but got Unknown
//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
//IL_00c1: Expected O, but got Unknown
maxStack = ((BaseUnityPlugin)this).Config.Bind<int>("General", "Max Stack Size", 4096, "Maximum item stack count this mod will try to reach.");
baseSize = ((BaseUnityPlugin)this).Config.Bind<int>("General", "Base Size", 2, "Exponential base. 2 gives 1,2,4,8... 3 gives 1,3,9,27...");
affectTierless = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Affect Tierless Items", false, "Usually safer off. Some hidden/itemless tokens are tierless and can be weird.");
affectEquipment = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Affect Equipment", false, "Placeholder safety option. Inventory.GiveItem should not normally affect equipment.");
RegisterArtifact();
Inventory.GiveItem_ItemIndex_int += new hook_GiveItem_ItemIndex_int(Inventory_GiveItem_ItemIndex_int);
Inventory.GiveItem_ItemDef_int += new hook_GiveItem_ItemDef_int(Inventory_GiveItem_ItemDef_int);
GenericPickupController.AttemptGrant += new hook_AttemptGrant(GenericPickupController_AttemptGrant);
((BaseUnityPlugin)this).Logger.LogInfo((object)string.Format("{0} loaded. Artifact registered: {1}", "ExponentialItemsReloaded", (Object)(object)exponentialArtifactDef != (Object)null));
}
private void RegisterArtifact()
{
LanguageAPI.Add("ARTIFACT_EXPONENTIALITEMS_NAME", "Artifact of Exponents");
LanguageAPI.Add("ARTIFACT_EXPONENTIALITEMS_DESC", "Items stack exponentially instead of one at a time.");
exponentialArtifactDef = ScriptableObject.CreateInstance<ArtifactDef>();
exponentialArtifactDef.cachedName = "ExponentialItems";
exponentialArtifactDef.nameToken = "ARTIFACT_EXPONENTIALITEMS_NAME";
exponentialArtifactDef.descriptionToken = "ARTIFACT_EXPONENTIALITEMS_DESC";
Sprite smallIconSelectedSprite = LoadSprite("icon_selected.png");
Sprite smallIconDeselectedSprite = LoadSprite("icon_deselected.png");
exponentialArtifactDef.smallIconSelectedSprite = smallIconSelectedSprite;
exponentialArtifactDef.smallIconDeselectedSprite = smallIconDeselectedSprite;
ContentAddition.AddArtifactDef(exponentialArtifactDef);
}
private static Sprite CreateIcon(Color color)
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Expected O, but got Unknown
//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
//IL_00d7: 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_0075: Unknown result type (might be due to invalid IL or missing references)
Texture2D val = new Texture2D(128, 128, (TextureFormat)4, false);
for (int i = 0; i < 128; i++)
{
for (int j = 0; j < 128; j++)
{
float num = (float)j - 64f;
float num2 = (float)i - 64f;
float num3 = Mathf.Sqrt(num * num + num2 * num2) / 64f;
bool flag = num3 > 0.72f && num3 < 0.86f;
bool flag2 = num3 < 0.48f;
val.SetPixel(j, i, (flag || flag2) ? color : Color.clear);
}
}
val.Apply();
return Sprite.Create(val, new Rect(0f, 0f, 128f, 128f), new Vector2(0.5f, 0.5f), 100f);
}
private void Inventory_GiveItem_ItemIndex_int(orig_GiveItem_ItemIndex_int orig, Inventory self, ItemIndex itemIndex, int count)
{
//IL_0091: 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_002b: 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_0049: Unknown result type (might be due to invalid IL or missing references)
//IL_0067: Unknown result type (might be due to invalid IL or missing references)
try
{
if (suppressExponentialHook || !ShouldApply(self, itemIndex, count))
{
orig.Invoke(self, itemIndex, count);
return;
}
int itemCountPermanent = self.GetItemCountPermanent(itemIndex);
int nextTargetStack = GetNextTargetStack(itemCountPermanent);
if (nextTargetStack <= itemCountPermanent)
{
orig.Invoke(self, itemIndex, count);
return;
}
int num = Math.Max(1, nextTargetStack - itemCountPermanent);
suppressExponentialHook = true;
try
{
orig.Invoke(self, itemIndex, num);
}
finally
{
suppressExponentialHook = false;
}
}
catch (Exception ex)
{
((BaseUnityPlugin)this).Logger.LogError((object)ex);
orig.Invoke(self, itemIndex, count);
}
}
private void Inventory_GiveItem_ItemDef_int(orig_GiveItem_ItemDef_int orig, Inventory self, ItemDef itemDef, int count)
{
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
//IL_005d: Expected O, but got Unknown
if ((Object)(object)itemDef == (Object)null)
{
orig.Invoke(self, itemDef, count);
return;
}
Inventory_GiveItem_ItemIndex_int((orig_GiveItem_ItemIndex_int)delegate(Inventory inventory, ItemIndex itemIndex, int itemCount)
{
orig.Invoke(inventory, itemDef, itemCount);
}, self, itemDef.itemIndex, count);
}
private void GenericPickupController_AttemptGrant(orig_AttemptGrant orig, GenericPickupController self, CharacterBody body)
{
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Invalid comparison between Unknown and I4
//IL_003f: 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_005c: Invalid comparison between Unknown and I4
//IL_0074: 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)
//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
Inventory val = (Object.op_Implicit((Object)(object)body) ? body.inventory : null);
PickupIndex pickupIndex = self.pickupIndex;
PickupDef pickupDef = PickupCatalog.GetPickupDef(pickupIndex);
ItemIndex val2 = (ItemIndex)((pickupDef == null) ? (-1) : ((int)pickupDef.itemIndex));
int num = (((Object)(object)val != (Object)null && (int)val2 != -1) ? val.GetItemCountPermanent(val2) : 0);
orig.Invoke(self, body);
try
{
if ((Object)(object)val == (Object)null || (int)val2 == -1 || suppressExponentialHook || !ShouldApplyItem(val, val2))
{
return;
}
int itemCountPermanent = val.GetItemCountPermanent(val2);
if (itemCountPermanent <= num)
{
return;
}
int nextTargetStack = GetNextTargetStack(num);
if (nextTargetStack <= itemCountPermanent)
{
return;
}
suppressExponentialHook = true;
try
{
val.GiveItemPermanent(val2, nextTargetStack - itemCountPermanent);
}
finally
{
suppressExponentialHook = false;
}
}
catch (Exception ex)
{
((BaseUnityPlugin)this).Logger.LogError((object)ex);
}
}
private static int GetNextTargetStack(int current)
{
int num = Math.Max(1, baseSize.Value);
int num2 = Math.Max(1, maxStack.Value);
if (current <= 0 || num <= 1 || current >= num2)
{
return current;
}
double y = Math.Floor(Math.Log(current, num)) + 1.0;
return (int)Math.Min(num2, Math.Pow(num, y));
}
private static bool ShouldApplyItem(Inventory self, ItemIndex itemIndex)
{
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Invalid comparison between Unknown and I4
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
//IL_007d: Unknown result type (might be due to invalid IL or missing references)
//IL_0083: Invalid comparison between Unknown and I4
if ((Object)(object)self == (Object)null || (int)itemIndex == -1)
{
return false;
}
if ((Object)(object)RunArtifactManager.instance == (Object)null || (Object)(object)exponentialArtifactDef == (Object)null)
{
return false;
}
if (!RunArtifactManager.instance.IsArtifactEnabled(exponentialArtifactDef))
{
return false;
}
ItemDef itemDef = ItemCatalog.GetItemDef(itemIndex);
if ((Object)(object)itemDef == (Object)null)
{
return false;
}
if (!affectTierless.Value && (int)itemDef.tier == 5)
{
return false;
}
return true;
}
private static bool ShouldApply(Inventory self, ItemIndex itemIndex, int count)
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
if (count != 1)
{
return false;
}
return ShouldApplyItem(self, itemIndex);
}
}
}
