using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
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.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HG.Reflection;
using HarmonyLib;
using ItemQualities;
using Microsoft.CodeAnalysis;
using RiskOfOptions;
using RiskOfOptions.Options;
using RoR2;
using RoR2.Items;
using UnityEngine;
using UnityEngine.Events;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: OptIn]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("ScrapMe")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+dd0d94e6831e6d6098a0cc3571d58899b30038d1")]
[assembly: AssemblyProduct("ScrapMe")]
[assembly: AssemblyTitle("ScrapMe")]
[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.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace ScrapMe
{
public class BanRecords
{
public class CharItemRecord
{
internal Dictionary<BodyIndex, HashSet<ItemIndex>> record = new Dictionary<BodyIndex, HashSet<ItemIndex>>();
public HashSet<ItemIndex> this[BodyIndex index]
{
get
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
return GetValue(index);
}
set
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
record[index] = value;
}
}
private HashSet<ItemIndex> GetValue(BodyIndex key)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: 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)
if (!record.ContainsKey(key))
{
record[key] = new HashSet<ItemIndex>();
}
return record[key];
}
}
internal class PresetBans
{
private readonly string charName;
private readonly HashSet<string> itemNames;
public PresetBans(string bodyName, IEnumerable<string> itemNames)
{
charName = bodyName;
this.itemNames = new HashSet<string>(itemNames);
}
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
public void Resolve()
{
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: 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: Invalid comparison between Unknown and I4
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_006f: Unknown result type (might be due to invalid IL or missing references)
//IL_0071: Unknown result type (might be due to invalid IL or missing references)
//IL_0074: Invalid comparison between Unknown and I4
//IL_0097: Unknown result type (might be due to invalid IL or missing references)
//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
if (charName == null)
{
return;
}
BodyIndex val = BodyCatalog.FindBodyIndex(charName);
if ((int)val == -1)
{
Log.Warning("Couldn't find body matching " + charName + ", skipping");
return;
}
HashSet<ItemIndex> hashSet = new HashSet<ItemIndex>();
foreach (string itemName in itemNames)
{
ItemIndex val2 = ItemCatalog.FindItemIndex(itemName);
if ((int)val2 == -1)
{
Log.Message("Couldn't find item matching " + itemName + ", skipping");
}
else
{
hashSet.Add(val2);
}
}
ScrapMe.plugin.bans.dev[val].UnionWith(hashSet);
if (QualityCompat.enabled)
{
QualityCompat.SetQualityVariantBans(val);
}
}
}
public CharItemRecord dev = new CharItemRecord();
internal CharItemRecord quality = new CharItemRecord();
internal CharItemRecord user = new CharItemRecord();
internal CharItemRecord unbans = new CharItemRecord();
internal static readonly List<PresetBans> presets = new List<PresetBans>(2)
{
new PresetBans("RobRavagerBody", new <>z__ReadOnlyArray<string>(new string[2] { "JumpBoost", "JumpDamageStrike" })),
new PresetBans("RobBelmontBody", new <>z__ReadOnlyArray<string>(new string[3] { "BarrierOnCooldown", "JumpBoost", "JumpDamageStrike" }))
};
internal IEnumerable<BodyIndex> MappedBodies => dev.record.Keys.Union(quality.record.Keys).Union(user.record.Keys).Union(unbans.record.Keys);
public HashSet<ItemIndex> All(BodyIndex index, bool withQuality = true)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
IEnumerable<ItemIndex> first = dev[index].Union(user[index]);
if (withQuality)
{
first = first.Union(quality[index]);
}
return first.Except(unbans[index]).ToHashSet();
}
}
internal class ConfigManager
{
public readonly ConfigEntry<string> charNames = ((BaseUnityPlugin)ScrapMe.plugin).Config.Bind<string>("! Main", "Characters to Change", "", "Characters to look for, comma-separated. Must be as prefab names, i.e. CommandoBody.");
public readonly Dictionary<string, ConfigEntry<string>> itemBans = new Dictionary<string, ConfigEntry<string>>();
public readonly Dictionary<string, ConfigEntry<string>> itemUnbans = new Dictionary<string, ConfigEntry<string>>();
public readonly HashSet<string> mappedChars = new HashSet<string>();
public bool BindBody(string body)
{
if (!mappedChars.Add(body))
{
return false;
}
ConfigEntry<string> val = ((BaseUnityPlugin)ScrapMe.plugin).Config.Bind<string>("Characters", body + "_ItemBans", "", "Items to auto-scrap for " + body + ", comma-separated, using prefab names, i.e. HealingPotion.");
itemBans[body] = val;
RiskOfOptionsCompat.CreateConfigEntry(val);
ConfigEntry<string> val2 = ((BaseUnityPlugin)ScrapMe.plugin).Config.Bind<string>("Characters", body + "_ItemUnbans", "", "Unbanned items for " + body + ". Use at your own risk; the items were likely banned for a reason.");
itemUnbans[body] = val2;
RiskOfOptionsCompat.CreateConfigEntry(val2);
return true;
}
public void Load()
{
//IL_0087: Unknown result type (might be due to invalid IL or missing references)
//IL_008c: Unknown result type (might be due to invalid IL or missing references)
//IL_010f: Unknown result type (might be due to invalid IL or missing references)
//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
((BaseUnityPlugin)ScrapMe.plugin).Config.SaveOnConfigSet = false;
IEnumerable<string> enumerable = from b in charNames.Value.Split(",")
select b.Trim() into b
where !string.IsNullOrEmpty(b)
select b;
foreach (string item in enumerable)
{
BodyIndex val = BodyCatalog.FindBodyIndex(item);
BindBody(item);
HashSet<string> source = new HashSet<string>(from b in itemBans[item].Value.Split(",")
select b.Trim() into b
where !string.IsNullOrEmpty(b)
select b);
ScrapMe.plugin.bans.user[val] = new HashSet<ItemIndex>(((IEnumerable<string>)source).Select((Func<string, ItemIndex>)ItemCatalog.FindItemIndex));
HashSet<string> source2 = new HashSet<string>(from b in itemUnbans[item].Value.Split(",")
select b.Trim() into b
where !string.IsNullOrEmpty(b)
select b);
ScrapMe.plugin.bans.unbans[val] = new HashSet<ItemIndex>(((IEnumerable<string>)source2).Select((Func<string, ItemIndex>)ItemCatalog.FindItemIndex));
if (QualityCompat.enabled)
{
QualityCompat.SetQualityVariantBans(val);
}
}
((BaseUnityPlugin)ScrapMe.plugin).Config.Save();
((BaseUnityPlugin)ScrapMe.plugin).Config.SaveOnConfigSet = true;
}
public void Cleanup()
{
}
public bool UnbindBody(string bodyName)
{
if (RiskOfOptionsCompat.mappedEntries.Contains(bodyName))
{
return false;
}
((BaseUnityPlugin)ScrapMe.plugin).Config.Remove(((ConfigEntryBase)itemBans[bodyName]).Definition);
((BaseUnityPlugin)ScrapMe.plugin).Config.Remove(((ConfigEntryBase)itemUnbans[bodyName]).Definition);
return true;
}
}
internal static class Log
{
private static ManualLogSource _logSource;
internal static void Init(ManualLogSource logSource)
{
_logSource = logSource;
}
internal static void Debug(object data)
{
_logSource.LogDebug(data);
}
internal static void Error(object data)
{
_logSource.LogError(data);
}
internal static void Fatal(object data)
{
_logSource.LogFatal(data);
}
internal static void Info(object data)
{
_logSource.LogInfo(data);
}
internal static void Message(object data)
{
_logSource.LogMessage(data);
}
internal static void Warning(object data)
{
_logSource.LogWarning(data);
}
}
public static class QualityCompat
{
private static bool? _enabled;
public static bool enabled
{
get
{
if (!_enabled.HasValue)
{
_enabled = Chainloader.PluginInfos.ContainsKey("com.Gorakh.ItemQualities");
}
return _enabled.Value;
}
}
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
public static void SetQualityVariantBans()
{
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: 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)
if (!enabled)
{
return;
}
ScrapMe.plugin.bans.quality.record.Clear();
foreach (BodyIndex mappedBody in ScrapMe.plugin.bans.MappedBodies)
{
SetQualityVariantBans(mappedBody);
}
}
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
public static void SetQualityVariantBans(BodyIndex bodyIndex)
{
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
//IL_0053: 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_005a: Unknown result type (might be due to invalid IL or missing references)
//IL_0086: Unknown result type (might be due to invalid IL or missing references)
//IL_0089: Invalid comparison between Unknown and I4
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_0060: Unknown result type (might be due to invalid IL or missing references)
//IL_0062: 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)
//IL_0069: Unknown result type (might be due to invalid IL or missing references)
//IL_006c: Invalid comparison between Unknown and I4
//IL_0077: Unknown result type (might be due to invalid IL or missing references)
//IL_0080: Unknown result type (might be due to invalid IL or missing references)
//IL_0083: Unknown result type (might be due to invalid IL or missing references)
//IL_0084: Unknown result type (might be due to invalid IL or missing references)
if (!enabled)
{
return;
}
HashSet<ItemIndex> hashSet = ScrapMe.plugin.bans.quality[bodyIndex];
hashSet.Clear();
foreach (ItemIndex item in ScrapMe.plugin.bans.All(bodyIndex, withQuality: false))
{
for (QualityTier val = (QualityTier)(QualityCatalog.GetQualityTier(item) + 1); (int)val < 4; val = (QualityTier)(val + 1))
{
ItemIndex itemIndexOfQuality = QualityCatalog.GetItemIndexOfQuality(item, val);
if ((int)itemIndexOfQuality != -1)
{
hashSet.Add(itemIndexOfQuality);
}
}
}
}
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
internal static ItemIndex CarryQualityToNewItem(ItemIndex oldItem, ItemIndex newItem)
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: 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_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: 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)
if (!enabled)
{
return newItem;
}
if (QualityCatalog.GetQualityTier(oldItem) == QualityCatalog.GetQualityTier(newItem))
{
return newItem;
}
return QualityCatalog.GetItemIndexOfQuality(newItem, QualityCatalog.GetQualityTier(oldItem));
}
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
internal static IEnumerable<ItemIndex> GetQualityVariants(ItemIndex baseItemIndex)
{
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: 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_0031: Expected I4, but got Unknown
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
//IL_003a: Expected I4, but got Unknown
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: Expected I4, but got Unknown
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_004c: Expected I4, but got Unknown
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: Expected I4, but got Unknown
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
if (!enabled)
{
return new <>z__ReadOnlySingleElementList<ItemIndex>(baseItemIndex);
}
ItemQualityGroup itemQualityGroup = QualityCatalog.GetItemQualityGroup(QualityCatalog.FindItemQualityGroupIndex(baseItemIndex));
return new <>z__ReadOnlyArray<ItemIndex>((ItemIndex[])(object)new ItemIndex[5]
{
(ItemIndex)(int)itemQualityGroup.BaseItemIndex,
(ItemIndex)(int)itemQualityGroup.UncommonItemIndex,
(ItemIndex)(int)itemQualityGroup.RareItemIndex,
(ItemIndex)(int)itemQualityGroup.EpicItemIndex,
(ItemIndex)(int)itemQualityGroup.LegendaryItemIndex
});
}
}
public static class RiskOfOptionsCompat
{
[CompilerGenerated]
private static class <>O
{
public static UnityAction <0>__CreateCurrentBodyEntry;
}
private static bool? _enabled;
internal static readonly HashSet<string> mappedEntries = new HashSet<string>();
public static bool enabled
{
get
{
if (!_enabled.HasValue)
{
_enabled = Chainloader.PluginInfos.ContainsKey("com.rune580.riskofoptions");
}
return _enabled.Value;
}
}
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
internal static void InitConfigMenu()
{
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Expected O, but got Unknown
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: Expected O, but got Unknown
//IL_0073: Unknown result type (might be due to invalid IL or missing references)
//IL_007d: Expected O, but got Unknown
//IL_0078: Unknown result type (might be due to invalid IL or missing references)
//IL_0082: Expected O, but got Unknown
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
//IL_004e: Expected O, but got Unknown
if (enabled)
{
ModSettingsManager.AddOption((BaseOption)new StringInputFieldOption(ScrapMe.plugin.configManager.charNames));
object obj = <>O.<0>__CreateCurrentBodyEntry;
if (obj == null)
{
UnityAction val = CreateCurrentBodyEntry;
<>O.<0>__CreateCurrentBodyEntry = val;
obj = (object)val;
}
ModSettingsManager.AddOption((BaseOption)new GenericButtonOption("Create Entry for Current Character", "! Main", (UnityAction)obj));
ModSettingsManager.AddOption((BaseOption)new GenericButtonOption("Apply Changes", "! Main", new UnityAction(ScrapMe.plugin.configManager.Load)));
}
}
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
internal static void CreateCurrentBodyEntry()
{
IEnumerable<string> enumerable = PlayerCharacterMasterController.instances.Select((PlayerCharacterMasterController b) => ((Object)b.body).name);
foreach (string item in enumerable)
{
string prefabNameFromClone = Utils.GetPrefabNameFromClone(item);
if (ScrapMe.plugin.configManager.BindBody(prefabNameFromClone))
{
ConfigEntry<string> charNames = ScrapMe.plugin.configManager.charNames;
charNames.Value = charNames.Value + "," + prefabNameFromClone;
Log.Info("Created entry for body " + prefabNameFromClone);
}
else
{
Log.Info("Already had entry for " + prefabNameFromClone + ", skipping");
}
}
}
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
internal static void CreateConfigEntry(ConfigEntry<string> associated)
{
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Expected O, but got Unknown
if (enabled)
{
string key = ((ConfigEntryBase)associated).Definition.Key;
if (!mappedEntries.Contains(key))
{
ModSettingsManager.AddOption((BaseOption)new StringInputFieldOption(associated));
mappedEntries.Add(key);
}
}
}
}
public static class RoR2EventHooks
{
public static void Register()
{
RoR2Application.onLoad = (Action)Delegate.Combine(RoR2Application.onLoad, new Action(OnLoad));
ItemTransformation.onItemTransformedServerGlobal += HandleItemTransform;
}
public static void HandleItemTransform(TryTransformResult result)
{
//IL_0001: 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_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Invalid comparison between Unknown and I4
//IL_0035: Unknown result type (might be due to invalid IL or missing references)
//IL_0084: Unknown result type (might be due to invalid IL or missing references)
//IL_008f: Unknown result type (might be due to invalid IL or missing references)
//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
//IL_00a9: 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_00ad: Unknown result type (might be due to invalid IL or missing references)
//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
//IL_00be: Invalid comparison between Unknown and I4
//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
//IL_0109: Unknown result type (might be due to invalid IL or missing references)
//IL_010e: Unknown result type (might be due to invalid IL or missing references)
//IL_0110: Unknown result type (might be due to invalid IL or missing references)
//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
//IL_012b: Unknown result type (might be due to invalid IL or missing references)
//IL_0131: Unknown result type (might be due to invalid IL or missing references)
Inventory inventory = result.inventory;
if ((Object)(object)inventory == (Object)null)
{
return;
}
ItemIndex itemIndex = result.givenItem.itemIndex;
if ((int)itemIndex == -1 || Utils.IsCorrespondingVoidInInv(itemIndex, inventory))
{
return;
}
CharacterMaster component = ((Component)inventory).GetComponent<CharacterMaster>();
if ((Object)(object)component == (Object)null)
{
return;
}
CharacterBody body = component.GetBody();
if ((Object)(object)body == (Object)null || !ScrapMe.plugin.bans.All(body.bodyIndex).Contains(itemIndex))
{
return;
}
ItemIndex replacementItem = Utils.GetReplacementItem(itemIndex);
if (replacementItem != itemIndex)
{
if ((int)replacementItem == -1)
{
Log.Warning($"Replacing transformed item {itemIndex} with no item");
}
ItemTransformation val = default(ItemTransformation);
((ItemTransformation)(ref val)).originalItemIndex = itemIndex;
((ItemTransformation)(ref val)).newItemIndex = replacementItem;
((ItemTransformation)(ref val)).maxToTransform = int.MaxValue;
val.transformationType = (ItemTransformationTypeIndex)(-1);
ItemTransformation val2 = val;
TryTransformResult val3 = default(TryTransformResult);
if (!((ItemTransformation)(ref val2)).TryTransform(inventory, ref val3))
{
Log.Warning($"Failed to replace transformed item {itemIndex} with {replacementItem}");
}
}
}
public static void OnLoad()
{
ScrapMe plugin = ScrapMe.plugin;
plugin.PresetBans();
plugin.configManager.Load();
RiskOfOptionsCompat.InitConfigMenu();
}
}
internal static class RoR2Patches
{
[HarmonyPatch(typeof(GenericPickupController), "AttemptGrant")]
[HarmonyPrefix]
public static void ReplaceWithScrapIfBannedForChar(CharacterBody body, GenericPickupController __instance, bool __runOriginal)
{
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_0054: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: Invalid comparison between Unknown and I4
//IL_0098: Unknown result type (might be due to invalid IL or missing references)
//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
//IL_00f1: Invalid comparison between Unknown and I4
//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
//IL_0105: Unknown result type (might be due to invalid IL or missing references)
//IL_010a: Unknown result type (might be due to invalid IL or missing references)
//IL_010f: Unknown result type (might be due to invalid IL or missing references)
//IL_0123: Unknown result type (might be due to invalid IL or missing references)
//IL_0138: Unknown result type (might be due to invalid IL or missing references)
//IL_0140: Unknown result type (might be due to invalid IL or missing references)
//IL_0142: Unknown result type (might be due to invalid IL or missing references)
//IL_014a: Unknown result type (might be due to invalid IL or missing references)
//IL_015c: Unknown result type (might be due to invalid IL or missing references)
//IL_016b: Unknown result type (might be due to invalid IL or missing references)
if (!__runOriginal || (Object)(object)__instance == (Object)null || (Object)(object)body == (Object)null)
{
return;
}
HashSet<ItemIndex> hashSet = ScrapMe.plugin.bans.All(body.bodyIndex);
if (hashSet.Count == 0)
{
return;
}
UniquePickup pickup = __instance.pickup;
PickupDef pickupDef = PickupCatalog.GetPickupDef(pickup.pickupIndex);
if (pickupDef == null || (int)pickupDef.itemIndex == -1)
{
return;
}
Log.Debug(((Object)body).name + " picking up " + pickupDef.internalName);
if (hashSet.Contains(pickupDef.itemIndex) && !((Object)(object)body.inventory == (Object)null) && !Utils.IsCorrespondingVoidInInv(pickupDef.itemIndex, body.inventory))
{
ItemIndex replacementItem = Utils.GetReplacementItem(pickupDef.itemIndex);
if ((int)replacementItem != -1)
{
ItemDef itemDef = ItemCatalog.GetItemDef(replacementItem);
PickupIndex val = PickupCatalog.FindPickupIndex(itemDef.itemIndex);
Log.Info($"Replacing {pickupDef.internalName} with {((Object)itemDef).name} (index {val})");
__instance.pickup = new UniquePickup
{
pickupIndex = val,
decayValue = __instance.pickup.decayValue,
upgradeValue = __instance.pickup.upgradeValue
};
}
}
}
}
[BepInPlugin("not_score.ScrapMe", "ScrapMe", "0.3.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class ScrapMe : BaseUnityPlugin
{
public static ScrapMe plugin;
public const string PluginGUID = "not_score.ScrapMe";
public const string PluginAuthor = "not_score";
public const string PluginName = "ScrapMe";
public const string PluginVersion = "0.3.0";
internal ConfigManager configManager;
internal readonly BanRecords bans = new BanRecords();
internal void Awake()
{
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Expected O, but got Unknown
plugin = this;
Log.Init(((BaseUnityPlugin)this).Logger);
Harmony val = new Harmony("not_score.ScrapMe");
val.PatchAll(typeof(RoR2Patches));
configManager = new ConfigManager();
RoR2EventHooks.Register();
}
public HashSet<ItemIndex> GetDevBans(BodyIndex bodyIndex)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0002: Invalid comparison between Unknown and I4
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
return ((int)bodyIndex == -1) ? null : bans.dev[bodyIndex];
}
internal void PresetBans()
{
BanRecords.presets.ForEach(delegate(BanRecords.PresetBans preset)
{
preset.Resolve();
});
}
}
public static class Utils
{
private static Dictionary<ItemTier, ItemIndex> scrapLookup = new Dictionary<ItemTier, ItemIndex>();
[Obsolete]
public static string GetPrefabNameFromItem(string itemName)
{
return itemName.Substring(itemName.IndexOf("Index.") + 6);
}
public static ItemIndex GetScrapForTier(ItemTier tier)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: 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_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0049: Expected I4, but got Unknown
//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_006e: Unknown result type (might be due to invalid IL or missing references)
//IL_0080: Unknown result type (might be due to invalid IL or missing references)
//IL_0086: Unknown result type (might be due to invalid IL or missing references)
//IL_0098: Unknown result type (might be due to invalid IL or missing references)
//IL_009e: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: 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_00b0: Unknown result type (might be due to invalid IL or missing references)
//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
//IL_00df: Unknown result type (might be due to invalid IL or missing references)
if (!scrapLookup.ContainsKey(tier))
{
switch ((int)tier)
{
case 3:
scrapLookup[tier] = ItemCatalog.FindItemIndex("Pearl");
break;
case 0:
case 6:
scrapLookup[tier] = ItemCatalog.FindItemIndex("ScrapWhite");
break;
case 1:
case 7:
scrapLookup[tier] = ItemCatalog.FindItemIndex("ScrapGreen");
break;
case 2:
case 8:
scrapLookup[tier] = ItemCatalog.FindItemIndex("ScrapRed");
break;
case 4:
case 9:
scrapLookup[tier] = ItemCatalog.FindItemIndex("ScrapYellow");
break;
default:
Log.Error("Failed to find appropriate replacement for item in tier " + ((Object)ItemTierCatalog.GetItemTierDef(tier)).name);
return (ItemIndex)0;
}
}
return scrapLookup[tier];
}
public static ItemIndex GetReplacementItem(ItemIndex item)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: 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)
ItemIndex scrapForTier = GetScrapForTier(ItemCatalog.GetItemDef(item).tier);
if (QualityCompat.enabled)
{
return QualityCompat.CarryQualityToNewItem(item, scrapForTier);
}
return scrapForTier;
}
public static string GetPrefabNameFromClone(string cloneName)
{
return cloneName.Substring(0, cloneName.LastIndexOf("(Clone)"));
}
public static string SanitizePrefabName(string prefabName)
{
return prefabName;
}
public static void CheckInventory(CharacterBody body)
{
//IL_001c: 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_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
//IL_0082: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_006e: Unknown result type (might be due to invalid IL or missing references)
//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)body == (Object)null)
{
return;
}
HashSet<ItemIndex> hashSet = ScrapMe.plugin.bans.All(body.bodyIndex);
foreach (ItemIndex item in hashSet)
{
int itemCountPermanent = body.inventory.GetItemCountPermanent(item);
if (itemCountPermanent > 0)
{
body.inventory.RemoveItemPermanent(item, itemCountPermanent);
body.inventory.GiveItemPermanent(GetReplacementItem(item), itemCountPermanent);
}
float tempItemRawValue = body.inventory.GetTempItemRawValue(item);
if (tempItemRawValue > 0f)
{
body.inventory.RemoveItemTemp(item, (float)(int)Math.Ceiling(tempItemRawValue));
body.inventory.GiveItemTemp(GetReplacementItem(item), tempItemRawValue);
}
}
}
public static bool IsCorrespondingVoidInInv(ItemIndex item, Inventory inv)
{
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
return GetCorrespondingVoids(item).Any((ItemIndex i) => (int)i != -1 && inv.GetItemCountEffective(i) > 0);
}
internal static IEnumerable<ItemIndex> GetCorrespondingVoids(ItemIndex corruptionCheck)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_000a: Invalid comparison between Unknown and I4
//IL_002a: 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)
ItemIndex transformedItemIndex = ContagiousItemManager.GetTransformedItemIndex(corruptionCheck);
if ((int)transformedItemIndex == -1)
{
return Array.Empty<ItemIndex>();
}
if (QualityCompat.enabled)
{
return QualityCompat.GetQualityVariants(transformedItemIndex);
}
return new <>z__ReadOnlySingleElementList<ItemIndex>(transformedItemIndex);
}
}
}
[CompilerGenerated]
internal sealed class <>z__ReadOnlyArray<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
int ICollection.Count => _items.Length;
bool ICollection.IsSynchronized => false;
object ICollection.SyncRoot => this;
object IList.this[int index]
{
get
{
return _items[index];
}
set
{
throw new NotSupportedException();
}
}
bool IList.IsFixedSize => true;
bool IList.IsReadOnly => true;
int IReadOnlyCollection<T>.Count => _items.Length;
T IReadOnlyList<T>.this[int index] => _items[index];
int ICollection<T>.Count => _items.Length;
bool ICollection<T>.IsReadOnly => true;
T IList<T>.this[int index]
{
get
{
return _items[index];
}
set
{
throw new NotSupportedException();
}
}
public <>z__ReadOnlyArray(T[] items)
{
_items = items;
}
IEnumerator IEnumerable.GetEnumerator()
{
return ((IEnumerable)_items).GetEnumerator();
}
void ICollection.CopyTo(Array array, int index)
{
((ICollection)_items).CopyTo(array, index);
}
int IList.Add(object value)
{
throw new NotSupportedException();
}
void IList.Clear()
{
throw new NotSupportedException();
}
bool IList.Contains(object value)
{
return ((IList)_items).Contains(value);
}
int IList.IndexOf(object value)
{
return ((IList)_items).IndexOf(value);
}
void IList.Insert(int index, object value)
{
throw new NotSupportedException();
}
void IList.Remove(object value)
{
throw new NotSupportedException();
}
void IList.RemoveAt(int index)
{
throw new NotSupportedException();
}
IEnumerator<T> IEnumerable<T>.GetEnumerator()
{
return ((IEnumerable<T>)_items).GetEnumerator();
}
void ICollection<T>.Add(T item)
{
throw new NotSupportedException();
}
void ICollection<T>.Clear()
{
throw new NotSupportedException();
}
bool ICollection<T>.Contains(T item)
{
return ((ICollection<T>)_items).Contains(item);
}
void ICollection<T>.CopyTo(T[] array, int arrayIndex)
{
((ICollection<T>)_items).CopyTo(array, arrayIndex);
}
bool ICollection<T>.Remove(T item)
{
throw new NotSupportedException();
}
int IList<T>.IndexOf(T item)
{
return ((IList<T>)_items).IndexOf(item);
}
void IList<T>.Insert(int index, T item)
{
throw new NotSupportedException();
}
void IList<T>.RemoveAt(int index)
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
internal sealed class <>z__ReadOnlySingleElementList<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
private sealed class Enumerator : IDisposable, IEnumerator, IEnumerator<T>
{
object IEnumerator.Current => _item;
T IEnumerator<T>.Current => _item;
public Enumerator(T item)
{
_item = item;
}
bool IEnumerator.MoveNext()
{
return !_moveNextCalled && (_moveNextCalled = true);
}
void IEnumerator.Reset()
{
_moveNextCalled = false;
}
void IDisposable.Dispose()
{
}
}
int ICollection.Count => 1;
bool ICollection.IsSynchronized => false;
object ICollection.SyncRoot => this;
object IList.this[int index]
{
get
{
if (index != 0)
{
throw new IndexOutOfRangeException();
}
return _item;
}
set
{
throw new NotSupportedException();
}
}
bool IList.IsFixedSize => true;
bool IList.IsReadOnly => true;
int IReadOnlyCollection<T>.Count => 1;
T IReadOnlyList<T>.this[int index]
{
get
{
if (index != 0)
{
throw new IndexOutOfRangeException();
}
return _item;
}
}
int ICollection<T>.Count => 1;
bool ICollection<T>.IsReadOnly => true;
T IList<T>.this[int index]
{
get
{
if (index != 0)
{
throw new IndexOutOfRangeException();
}
return _item;
}
set
{
throw new NotSupportedException();
}
}
public <>z__ReadOnlySingleElementList(T item)
{
_item = item;
}
IEnumerator IEnumerable.GetEnumerator()
{
return new Enumerator(_item);
}
void ICollection.CopyTo(Array array, int index)
{
array.SetValue(_item, index);
}
int IList.Add(object value)
{
throw new NotSupportedException();
}
void IList.Clear()
{
throw new NotSupportedException();
}
bool IList.Contains(object value)
{
return EqualityComparer<T>.Default.Equals(_item, (T)value);
}
int IList.IndexOf(object value)
{
return (!EqualityComparer<T>.Default.Equals(_item, (T)value)) ? (-1) : 0;
}
void IList.Insert(int index, object value)
{
throw new NotSupportedException();
}
void IList.Remove(object value)
{
throw new NotSupportedException();
}
void IList.RemoveAt(int index)
{
throw new NotSupportedException();
}
IEnumerator<T> IEnumerable<T>.GetEnumerator()
{
return new Enumerator(_item);
}
void ICollection<T>.Add(T item)
{
throw new NotSupportedException();
}
void ICollection<T>.Clear()
{
throw new NotSupportedException();
}
bool ICollection<T>.Contains(T item)
{
return EqualityComparer<T>.Default.Equals(_item, item);
}
void ICollection<T>.CopyTo(T[] array, int arrayIndex)
{
array[arrayIndex] = _item;
}
bool ICollection<T>.Remove(T item)
{
throw new NotSupportedException();
}
int IList<T>.IndexOf(T item)
{
return (!EqualityComparer<T>.Default.Equals(_item, item)) ? (-1) : 0;
}
void IList<T>.Insert(int index, T item)
{
throw new NotSupportedException();
}
void IList<T>.RemoveAt(int index)
{
throw new NotSupportedException();
}
}
