using System;
using System.Collections;
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.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HG.Coroutines;
using HG.Reflection;
using Microsoft.CodeAnalysis;
using On.RoR2;
using RiskOfOptions;
using RiskOfOptions.Options;
using RoR2;
using RoR2.Skills;
using UnityEngine;
[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("SkillsConfigurator")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+0ff8c0689331e0d3cd97adef6e6ffc972fbc8758")]
[assembly: AssemblyProduct("SkillsConfigurator")]
[assembly: AssemblyTitle("SkillsConfigurator")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
[module: UnverifiableCode]
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 SkillsConfigurator
{
public static class ModCompatabilities
{
public static class RiskOfOptionsCompatability
{
public const string GUID = "com.rune580.riskofoptions";
public static void AddConfig<T>(T config) where T : ConfigEntryBase
{
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Expected O, but got Unknown
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
//IL_0053: 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_009d: Unknown result type (might be due to invalid IL or missing references)
//IL_00a7: Expected O, but got Unknown
if (config is ConfigEntry<float>)
{
ModSettingsManager.AddOption((BaseOption)new FloatFieldOption(config as ConfigEntry<float>));
}
if (config is ConfigEntry<bool>)
{
ModSettingsManager.AddOption((BaseOption)new CheckBoxOption(config as ConfigEntry<bool>));
}
if (config is ConfigEntry<int>)
{
ModSettingsManager.AddOption((BaseOption)new IntFieldOption(config as ConfigEntry<int>));
}
if (config is ConfigEntry<string>)
{
ModSettingsManager.AddOption((BaseOption)new StringInputFieldOption(config as ConfigEntry<string>));
}
}
}
}
[Serializable]
[BepInPlugin("com.brynzananas.skillsconfigurator", "Skills Configurator", "1.2.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class SkillsConfiguratorPlugin : BaseUnityPlugin
{
[CompilerGenerated]
private static class <>O
{
public static hook_SetSkillVariant <0>__BodyLoadoutManager_SetSkillVariant;
}
[CompilerGenerated]
private sealed class <>c__DisplayClass27_0
{
public ParallelCoroutine loadCoroutine;
}
[CompilerGenerated]
private sealed class <>c__DisplayClass29_0
{
public SkillDef skillDef;
}
[CompilerGenerated]
private sealed class <>c__DisplayClass29_1
{
public ConfigEntry<float> baseRechargeInterval;
public ConfigEntry<int> baseMaxStock;
public ConfigEntry<int> rechargeStock;
public ConfigEntry<int> requiredStock;
public ConfigEntry<int> stockToConsume;
public ConfigEntry<bool> attackSpeedBuffsRestockSpeed;
public ConfigEntry<float> attackSpeedBuffsRestockSpeed_Multiplier;
public ConfigEntry<bool> resetCooldownTimerOnUse;
public ConfigEntry<bool> fullRestockOnAssign;
public ConfigEntry<bool> dontAllowPastMaxStocks;
public ConfigEntry<bool> beginSkillCooldownOnSkillEnd;
public ConfigEntry<bool> isCooldownBlockedUntilManuallyReset;
public ConfigEntry<bool> cancelSprintingOnActivation;
public ConfigEntry<bool> forceSprintDuringState;
public ConfigEntry<bool> canceledFromSprinting;
public ConfigEntry<bool> isCombatSkill;
public ConfigEntry<bool> mustKeyPress;
public ConfigEntry<bool> triggeredByPressRelease;
public ConfigEntry<bool> autoHandleLuminousShot;
public ConfigEntry<bool> suppressSkillActivation;
public <>c__DisplayClass29_0 CS$<>8__locals1;
}
[CompilerGenerated]
private sealed class <ConfigureSkillThread>d__29 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public SkillDef skillDef;
public int loc;
private <>c__DisplayClass29_0 <>8__1;
private string <sectionName>5__2;
private List<ConfigEntryBase> <configEntryBases>5__3;
private ConfigEntry<bool> <enable>5__4;
private <>c__DisplayClass29_1 <>8__5;
private List<ConfigEntryBase>.Enumerator <>s__6;
private ConfigEntryBase <configEntryBase>5__7;
private ConfigEntry<float> <configEntry>5__8;
private ConfigEntry<int> <configEntry2>5__9;
private ConfigEntry<bool> <configEntry1>5__10;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <ConfigureSkillThread>d__29(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>8__1 = null;
<sectionName>5__2 = null;
<configEntryBases>5__3 = null;
<enable>5__4 = null;
<>8__5 = null;
<>s__6 = default(List<ConfigEntryBase>.Enumerator);
<configEntryBase>5__7 = null;
<configEntry>5__8 = null;
<configEntry2>5__9 = null;
<configEntry1>5__10 = null;
<>1__state = -2;
}
private bool MoveNext()
{
if (<>1__state != 0)
{
return false;
}
<>1__state = -1;
<>8__1 = new <>c__DisplayClass29_0();
<>8__1.skillDef = skillDef;
<sectionName>5__2 = ((Object)<>8__1.skillDef).name;
<sectionName>5__2 = HandleString(<sectionName>5__2);
if (Utility.IsNullOrWhiteSpace(<sectionName>5__2))
{
<sectionName>5__2 = HandleString(<>8__1.skillDef.skillName);
}
if (Utility.IsNullOrWhiteSpace(<sectionName>5__2))
{
return false;
}
if (skillConfigs.ContainsKey(<>8__1.skillDef))
{
return false;
}
skillToNewName.Add(<>8__1.skillDef, <sectionName>5__2);
<configEntryBases>5__3 = new List<ConfigEntryBase>();
skillConfigs.Add(<>8__1.skillDef, <configEntryBases>5__3);
<enable>5__4 = CreateConfig(<sectionName>5__2, "Enable Config", defaultValue: false, "Enable configuration for this skill? AKA \"" + <>8__1.skillDef.skillName + "\" and \"" + Language.GetString(<>8__1.skillDef.skillNameToken) + "\"", null, enableRiskOfOptions: false);
if (<enable>5__4.Value)
{
<>8__5 = new <>c__DisplayClass29_1();
<>8__5.CS$<>8__locals1 = <>8__1;
<>8__5.baseRechargeInterval = CreateConfig(<sectionName>5__2, "Base Recharge Interval", <>8__5.CS$<>8__locals1.skillDef.baseRechargeInterval, "How long it takes for this skill to recharge after being used.", <configEntryBases>5__3, enableRiskOfOptions: true);
<>8__5.baseMaxStock = CreateConfig(<sectionName>5__2, "Base Max Stock", <>8__5.CS$<>8__locals1.skillDef.baseMaxStock, "Maximum number of charges this skill can carry.", <configEntryBases>5__3, enableRiskOfOptions: true);
<>8__5.rechargeStock = CreateConfig(<sectionName>5__2, "Recharge Stock", <>8__5.CS$<>8__locals1.skillDef.rechargeStock, "How much stock to restore on a recharge.", <configEntryBases>5__3, enableRiskOfOptions: true);
<>8__5.requiredStock = CreateConfig(<sectionName>5__2, "Required Stock", <>8__5.CS$<>8__locals1.skillDef.requiredStock, "How much stock is required to activate this skill.", <configEntryBases>5__3, enableRiskOfOptions: true);
<>8__5.stockToConsume = CreateConfig(<sectionName>5__2, "Stock To Consume", <>8__5.CS$<>8__locals1.skillDef.stockToConsume, "How much stock to deduct when the skill is activated.", <configEntryBases>5__3, enableRiskOfOptions: true);
<>8__5.attackSpeedBuffsRestockSpeed = CreateConfig(<sectionName>5__2, "Attack Speed Buffs Restock Speed", <>8__5.CS$<>8__locals1.skillDef.attackSpeedBuffsRestockSpeed, "Makes the skill restock interval divided by attack speed if checked.", <configEntryBases>5__3, enableRiskOfOptions: true);
<>8__5.attackSpeedBuffsRestockSpeed_Multiplier = CreateConfig(<sectionName>5__2, "Attack Speed Buffs Restock Speed Multiplier", <>8__5.CS$<>8__locals1.skillDef.attackSpeedBuffsRestockSpeed_Multiplier, "Increases the efficacy of attack speed on restock time.", <configEntryBases>5__3, enableRiskOfOptions: true);
<>8__5.resetCooldownTimerOnUse = CreateConfig(<sectionName>5__2, "Reset Cooldown Timer On Use", <>8__5.CS$<>8__locals1.skillDef.resetCooldownTimerOnUse, "Whether or not it resets any progress on cooldowns.", <configEntryBases>5__3, enableRiskOfOptions: true);
<>8__5.fullRestockOnAssign = CreateConfig(<sectionName>5__2, "Full Restock On Assign", <>8__5.CS$<>8__locals1.skillDef.fullRestockOnAssign, "Whether or not to fully restock this skill when it's assigned.", <configEntryBases>5__3, enableRiskOfOptions: true);
<>8__5.dontAllowPastMaxStocks = CreateConfig(<sectionName>5__2, "Dont Allow Past Max Stocks", <>8__5.CS$<>8__locals1.skillDef.dontAllowPastMaxStocks, "Whether or not this skill can hold past it's maximum stock.", <configEntryBases>5__3, enableRiskOfOptions: true);
<>8__5.beginSkillCooldownOnSkillEnd = CreateConfig(<sectionName>5__2, "Begin Skill Colldown On Skill End", <>8__5.CS$<>8__locals1.skillDef.beginSkillCooldownOnSkillEnd, "Whether or not the cooldown waits until it leaves the set state.", <configEntryBases>5__3, enableRiskOfOptions: true);
<>8__5.isCooldownBlockedUntilManuallyReset = CreateConfig(<sectionName>5__2, "Is Cooldown Blocked Until Manually Reset", <>8__5.CS$<>8__locals1.skillDef.isCooldownBlockedUntilManuallyReset, "Whether or not the skill is blocked from being used until it is manually reset", <configEntryBases>5__3, enableRiskOfOptions: true);
<>8__5.cancelSprintingOnActivation = CreateConfig(<sectionName>5__2, "Cancel Sprinting On Activation", <>8__5.CS$<>8__locals1.skillDef.cancelSprintingOnActivation, "Whether or not activating the skill forces off sprinting.", <configEntryBases>5__3, enableRiskOfOptions: true);
<>8__5.forceSprintDuringState = CreateConfig(<sectionName>5__2, "Force Sprint During State", <>8__5.CS$<>8__locals1.skillDef.forceSprintDuringState, "Whether or not this skill is considered 'mobility'. Currently just forces sprint.", <configEntryBases>5__3, enableRiskOfOptions: true);
<>8__5.canceledFromSprinting = CreateConfig(<sectionName>5__2, "Canceled From Sprinting", <>8__5.CS$<>8__locals1.skillDef.canceledFromSprinting, "Whether or not sprinting sets the skill's state to be reset.", <configEntryBases>5__3, enableRiskOfOptions: true);
<>8__5.isCombatSkill = CreateConfig(<sectionName>5__2, "Is Combat Skill", <>8__5.CS$<>8__locals1.skillDef.isCombatSkill, "Whether or not this is considered a combat skill.", <configEntryBases>5__3, enableRiskOfOptions: true);
<>8__5.mustKeyPress = CreateConfig(<sectionName>5__2, "Must Key Press", <>8__5.CS$<>8__locals1.skillDef.mustKeyPress, "The skill can't be activated if the key is held.", <configEntryBases>5__3, enableRiskOfOptions: true);
<>8__5.triggeredByPressRelease = CreateConfig(<sectionName>5__2, "Triggered By Press Release", <>8__5.CS$<>8__locals1.skillDef.triggeredByPressRelease, "Can this skill be triggered by an key release event?", <configEntryBases>5__3, enableRiskOfOptions: true);
<>8__5.autoHandleLuminousShot = CreateConfig(<sectionName>5__2, "Auto Handle Luminous Shot", <>8__5.CS$<>8__locals1.skillDef.autoHandleLuminousShot, "If true, CharacterBody handles LuminiousShot buffs. If false, the skill must handle it.", <configEntryBases>5__3, enableRiskOfOptions: true);
<>8__5.suppressSkillActivation = CreateConfig(<sectionName>5__2, "Suppress Skill Activation", <>8__5.CS$<>8__locals1.skillDef.suppressSkillActivation, "If true, CharacterBody.OnSkillActivated will not be called.", <configEntryBases>5__3, enableRiskOfOptions: true);
<>s__6 = <configEntryBases>5__3.GetEnumerator();
try
{
while (<>s__6.MoveNext())
{
<configEntryBase>5__7 = <>s__6.Current;
<configEntry>5__8 = <configEntryBase>5__7 as ConfigEntry<float>;
if (<configEntry>5__8 == null)
{
<configEntry2>5__9 = <configEntryBase>5__7 as ConfigEntry<int>;
if (<configEntry2>5__9 == null)
{
<configEntry1>5__10 = <configEntryBase>5__7 as ConfigEntry<bool>;
if (<configEntry1>5__10 == null)
{
continue;
}
<configEntry1>5__10.SettingChanged += ConfigEntry_SettingChanged;
<configEntry1>5__10 = null;
}
else
{
<configEntry2>5__9.SettingChanged += ConfigEntry_SettingChanged;
}
<configEntry2>5__9 = null;
}
else
{
<configEntry>5__8.SettingChanged += ConfigEntry_SettingChanged;
}
<configEntry>5__8 = null;
<configEntryBase>5__7 = null;
}
}
finally
{
((IDisposable)<>s__6).Dispose();
}
<>s__6 = default(List<ConfigEntryBase>.Enumerator);
UpdateSkillDef();
<>8__5 = null;
}
return false;
void ConfigEntry_SettingChanged(object sender, EventArgs e)
{
UpdateSkillDef();
}
void UpdateSkillDef()
{
((<>c__DisplayClass29_1)this).CS$<>8__locals1.skillDef.baseRechargeInterval = ((<>c__DisplayClass29_1)this).baseRechargeInterval.Value;
((<>c__DisplayClass29_1)this).CS$<>8__locals1.skillDef.baseMaxStock = ((<>c__DisplayClass29_1)this).baseMaxStock.Value;
((<>c__DisplayClass29_1)this).CS$<>8__locals1.skillDef.rechargeStock = ((<>c__DisplayClass29_1)this).rechargeStock.Value;
((<>c__DisplayClass29_1)this).CS$<>8__locals1.skillDef.requiredStock = ((<>c__DisplayClass29_1)this).requiredStock.Value;
((<>c__DisplayClass29_1)this).CS$<>8__locals1.skillDef.stockToConsume = ((<>c__DisplayClass29_1)this).stockToConsume.Value;
((<>c__DisplayClass29_1)this).CS$<>8__locals1.skillDef.attackSpeedBuffsRestockSpeed = ((<>c__DisplayClass29_1)this).attackSpeedBuffsRestockSpeed.Value;
((<>c__DisplayClass29_1)this).CS$<>8__locals1.skillDef.attackSpeedBuffsRestockSpeed_Multiplier = ((<>c__DisplayClass29_1)this).attackSpeedBuffsRestockSpeed_Multiplier.Value;
((<>c__DisplayClass29_1)this).CS$<>8__locals1.skillDef.resetCooldownTimerOnUse = ((<>c__DisplayClass29_1)this).resetCooldownTimerOnUse.Value;
((<>c__DisplayClass29_1)this).CS$<>8__locals1.skillDef.fullRestockOnAssign = ((<>c__DisplayClass29_1)this).fullRestockOnAssign.Value;
((<>c__DisplayClass29_1)this).CS$<>8__locals1.skillDef.dontAllowPastMaxStocks = ((<>c__DisplayClass29_1)this).dontAllowPastMaxStocks.Value;
((<>c__DisplayClass29_1)this).CS$<>8__locals1.skillDef.beginSkillCooldownOnSkillEnd = ((<>c__DisplayClass29_1)this).beginSkillCooldownOnSkillEnd.Value;
((<>c__DisplayClass29_1)this).CS$<>8__locals1.skillDef.isCooldownBlockedUntilManuallyReset = ((<>c__DisplayClass29_1)this).isCooldownBlockedUntilManuallyReset.Value;
((<>c__DisplayClass29_1)this).CS$<>8__locals1.skillDef.cancelSprintingOnActivation = ((<>c__DisplayClass29_1)this).cancelSprintingOnActivation.Value;
((<>c__DisplayClass29_1)this).CS$<>8__locals1.skillDef.forceSprintDuringState = ((<>c__DisplayClass29_1)this).forceSprintDuringState.Value;
((<>c__DisplayClass29_1)this).CS$<>8__locals1.skillDef.canceledFromSprinting = ((<>c__DisplayClass29_1)this).canceledFromSprinting.Value;
((<>c__DisplayClass29_1)this).CS$<>8__locals1.skillDef.isCombatSkill = ((<>c__DisplayClass29_1)this).isCombatSkill.Value;
((<>c__DisplayClass29_1)this).CS$<>8__locals1.skillDef.mustKeyPress = ((<>c__DisplayClass29_1)this).mustKeyPress.Value;
((<>c__DisplayClass29_1)this).CS$<>8__locals1.skillDef.triggeredByPressRelease = ((<>c__DisplayClass29_1)this).triggeredByPressRelease.Value;
((<>c__DisplayClass29_1)this).CS$<>8__locals1.skillDef.autoHandleLuminousShot = ((<>c__DisplayClass29_1)this).autoHandleLuminousShot.Value;
((<>c__DisplayClass29_1)this).CS$<>8__locals1.skillDef.suppressSkillActivation = ((<>c__DisplayClass29_1)this).suppressSkillActivation.Value;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
public const string ModGuid = "com.brynzananas.skillsconfigurator";
public const string ModName = "Skills Configurator";
public const string ModVer = "1.2.0";
public static Dictionary<SkillDef, List<ConfigEntryBase>> skillConfigs = new Dictionary<SkillDef, List<ConfigEntryBase>>();
public static Dictionary<string, int> names = new Dictionary<string, int>();
public static Dictionary<SkillDef, string> skillToNewName = new Dictionary<SkillDef, string>();
private static bool _debug;
private static Stopwatch stopwatch;
public static bool riskOfOptionsEnabled { get; private set; }
public static ConfigFile configFile { get; private set; }
public static ManualLogSource Log { get; private set; }
public static bool debug
{
get
{
return _debug;
}
set
{
//IL_0050: 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_005b: Expected O, but got Unknown
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Expected O, but got Unknown
if (value == _debug)
{
return;
}
_debug = value;
if (value)
{
object obj = <>O.<0>__BodyLoadoutManager_SetSkillVariant;
if (obj == null)
{
hook_SetSkillVariant val = BodyLoadoutManager_SetSkillVariant;
<>O.<0>__BodyLoadoutManager_SetSkillVariant = val;
obj = (object)val;
}
BodyLoadoutManager.SetSkillVariant += (hook_SetSkillVariant)obj;
}
else
{
object obj2 = <>O.<0>__BodyLoadoutManager_SetSkillVariant;
if (obj2 == null)
{
hook_SetSkillVariant val2 = BodyLoadoutManager_SetSkillVariant;
<>O.<0>__BodyLoadoutManager_SetSkillVariant = val2;
obj2 = (object)val2;
}
BodyLoadoutManager.SetSkillVariant -= (hook_SetSkillVariant)obj2;
}
}
}
public void Awake()
{
configFile = ((BaseUnityPlugin)this).Config;
Log = ((BaseUnityPlugin)this).Logger;
riskOfOptionsEnabled = Chainloader.PluginInfos.ContainsKey("com.rune580.riskofoptions");
}
public void OnDestroy()
{
debug = false;
}
private static void BodyLoadoutManager_SetSkillVariant(orig_SetSkillVariant orig, BodyLoadoutManager self, BodyIndex bodyIndex, int skillSlot, uint skillVariant)
{
//IL_0003: 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_0026: Expected I4, but got Unknown
orig.Invoke(self, bodyIndex, skillSlot, skillVariant);
if (skillSlot < 0 || skillVariant < 0)
{
return;
}
int num = (int)bodyIndex;
if (num < 0 || num >= BodyLoadoutManager.allBodyInfos.Length)
{
return;
}
GenericSkill[] prefabSkillSlots = BodyLoadoutManager.allBodyInfos[num].prefabSkillSlots;
if (prefabSkillSlots == null || skillSlot >= prefabSkillSlots.Length)
{
return;
}
GenericSkill val = prefabSkillSlots[skillSlot];
if (!Object.op_Implicit((Object)(object)val))
{
return;
}
SkillFamily skillFamily = val.skillFamily;
if (Object.op_Implicit((Object)(object)skillFamily) && skillVariant < skillFamily.variants.Length)
{
SkillDef skillDef = skillFamily.variants[skillVariant].skillDef;
if (Object.op_Implicit((Object)(object)skillDef))
{
string text = ((!skillToNewName.ContainsKey(skillDef)) ? ((Object)skillDef).name : skillToNewName[skillDef]);
Log.LogMessage((object)("Selected skill: \"" + text + "\" AKA \"" + skillDef.skillName + "\" and \"" + Language.GetString(skillDef.skillNameToken) + "\""));
}
}
}
[ConCommand(/*Could not decode attribute arguments.*/)]
public static void CCReset(ConCommandArgs args)
{
debug = ((ConCommandArgs)(ref args)).GetArgBool(0);
if (debug)
{
Log.LogMessage((object)"Enabled debug");
}
else
{
Log.LogMessage((object)"Disabled debug");
}
}
[SystemInitializer(new Type[] { typeof(SkillCatalog) })]
private static void ConfigureSkillsStart()
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Expected O, but got Unknown
<>c__DisplayClass27_0 CS$<>8__locals0 = new <>c__DisplayClass27_0();
configFile.SaveOnConfigSet = false;
Log.LogMessage((object)"Begin configuring skills");
CS$<>8__locals0.loadCoroutine = new ParallelCoroutine();
stopwatch = Stopwatch.StartNew();
stopwatch.Start();
int num = 0;
foreach (SkillDef allSkillDef in SkillCatalog.allSkillDefs)
{
num++;
CS$<>8__locals0.loadCoroutine.Add(ConfigureSkillThread(allSkillDef, num));
}
((MonoBehaviour)RoR2Application.instance).StartCoroutine(runLoadCoroutine());
[IteratorStateMachine(typeof(<>c__DisplayClass27_0.<<ConfigureSkillsStart>g__runLoadCoroutine|0>d))]
IEnumerator runLoadCoroutine()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <>c__DisplayClass27_0.<<ConfigureSkillsStart>g__runLoadCoroutine|0>d(0)
{
<>4__this = CS$<>8__locals0
};
}
}
private static string HandleString(string @string)
{
if (Utility.IsNullOrWhiteSpace(@string))
{
return @string;
}
char[] array = new char[6] { '\n', '\t', '"', '\'', '[', ']' };
char[] array2 = array;
foreach (char c in array2)
{
while (@string.Contains(c))
{
@string = @string.Replace(c, ' ');
}
}
@string.Trim();
int j;
for (j = 0; names.ContainsKey(@string + ((j == 0) ? "" : ((object)j))); j++)
{
}
@string += ((j == 0) ? "" : ((object)j));
names.Add(@string, j);
return @string;
}
[IteratorStateMachine(typeof(<ConfigureSkillThread>d__29))]
private static IEnumerator ConfigureSkillThread(SkillDef skillDef, int loc)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <ConfigureSkillThread>d__29(0)
{
skillDef = skillDef,
loc = loc
};
}
private static ConfigEntry<T> CreateConfig<T>(string section, string key, T defaultValue, string description, List<ConfigEntryBase> configEntryBases, bool enableRiskOfOptions)
{
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
//IL_0009: Expected O, but got Unknown
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Expected O, but got Unknown
ConfigDefinition val = new ConfigDefinition(section, key);
ConfigDescription val2 = new ConfigDescription(description, (AcceptableValueBase)null, Array.Empty<object>());
ConfigEntry<T> val3 = configFile.Bind<T>(val, defaultValue, val2);
configEntryBases?.Add((ConfigEntryBase)(object)val3);
if (enableRiskOfOptions && riskOfOptionsEnabled)
{
ModCompatabilities.RiskOfOptionsCompatability.AddConfig<ConfigEntry<T>>(val3);
}
return val3;
}
}
}
