using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Linq.Dynamic.Core;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using Bounce.ManagedCollections;
using Bounce.Singletons;
using Bounce.Unmanaged;
using Dice;
using GameChat.UI;
using HarmonyLib;
using ModdingTales;
using Newtonsoft.Json;
using RadialUI;
using TMPro;
using Unity.Mathematics;
using UnityEngine;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("D20Plugin")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Nth Dimension")]
[assembly: AssemblyProduct("D20Plugin")]
[assembly: AssemblyCopyright("Copyright ©  2026")]
[assembly: AssemblyTrademark("D20Plugin")]
[assembly: ComVisible(false)]
[assembly: Guid("c303405d-e66c-4316-9cdb-4e3ca15c6360")]
[assembly: AssemblyFileVersion("2.5.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("2.5.0.0")]
namespace LordAshes;

[BepInPlugin("org.lordashes.plugins.d20", "D20 Plugin", "2.5.0.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class PluginD20 : BaseUnityPlugin
{
	public static class Characters
	{
		public class SpecPair
		{
			public string key { get; set; } = "key";


			public string value { get; set; } = "Undefined";


			public SpecPair()
			{
			}

			public SpecPair(string key)
			{
				this.key = key;
				value = "Undefined";
			}

			public SpecPair(string key, string value)
			{
				this.key = key;
				this.value = value;
			}
		}

		public class Spec
		{
			public string name { get; set; } = "Skill";


			public string formula { get; set; } = null;


			public List<SpecPair> extra { get; set; } = null;


			public string menu { get; set; } = null;


			public Spec(string name, string formula, List<SpecPair> extra = null, string menu = null)
			{
				this.name = name;
				this.formula = formula;
				this.extra = extra;
				this.menu = menu;
			}

			public string Extra(string name)
			{
				return extra.Where((SpecPair e) => e.key == name).FirstOrDefault()?.value;
			}
		}

		public class CharacterSpecs
		{
			public string name { get; set; } = "Unnamed";


			public string chainSources { get; set; } = null;


			public List<Spec> specs { get; set; } = new List<Spec>();


			public void AddAbilityScore(string name, string value, string menu = null)
			{
				specs.Add(new Spec(name, ((int.Parse(value) >= 10) ? ((int.Parse(value) - 10) / 2) : ((int.Parse(value) - 11) / 2)).ToString(), new List<SpecPair>
				{
					new SpecPair("type", "ability"),
					new SpecPair("value", value)
				}, menu));
			}

			public void AddValue(string name, string value, string menu = null)
			{
				specs.Add(new Spec(name, value, new List<SpecPair>
				{
					new SpecPair("type", "value")
				}, menu));
			}

			public void AddSave(string name, string formula, string menu = null)
			{
				specs.Add(new Spec(name, formula, new List<SpecPair>
				{
					new SpecPair("type", "save")
				}, menu));
			}

			public void AddSkill(string name, string formula, string menu = null)
			{
				specs.Add(new Spec(name, formula, new List<SpecPair>
				{
					new SpecPair("type", "skill")
				}, menu));
			}

			public void AddSkill(string name, string formula, string opposed, string menu = null)
			{
				specs.Add(new Spec(name, formula, new List<SpecPair>
				{
					new SpecPair("type", "skill"),
					new SpecPair("opposed", opposed)
				}, menu));
			}

			public void AddAttack(string name, string formula, string opposed, string menu = null)
			{
				specs.Add(new Spec(name, formula, new List<SpecPair>
				{
					new SpecPair("type", "attack"),
					new SpecPair("opposed", opposed)
				}, menu));
			}

			public void AddDamage(string name, string formula, string damageType, string menu = null)
			{
				specs.Add(new Spec(name, formula, new List<SpecPair>
				{
					new SpecPair("type", "damage"),
					new SpecPair("damageType", damageType)
				}, menu));
			}

			public void AddHealing(string name, string formula, string menu = null)
			{
				specs.Add(new Spec(name, formula, new List<SpecPair>
				{
					new SpecPair("type", "heal")
				}, menu));
			}

			public void AddResistances(string name, string list, string damageType, string menu = null)
			{
				List<SpecPair> list2 = new List<SpecPair>();
				string[] array = list.Split(new char[1] { ',' });
				foreach (string text in array)
				{
					list2.Add(new SpecPair(text, text));
				}
				specs.Add(new Spec("Resistances", list, list2, menu));
			}

			public void AddImmunities(string name, string list, string damageType, string menu = null)
			{
				List<SpecPair> list2 = new List<SpecPair>();
				string[] array = list.Split(new char[1] { ',' });
				foreach (string text in array)
				{
					list2.Add(new SpecPair(text, text));
				}
				specs.Add(new Spec("Immunities", list, list2, menu));
			}

			public void AddVulnerabilities(string name, string list, string damageType, string menu = null)
			{
				List<SpecPair> list2 = new List<SpecPair>();
				string[] array = list.Split(new char[1] { ',' });
				foreach (string text in array)
				{
					list2.Add(new SpecPair(text, text));
				}
				specs.Add(new Spec("Resistances", list, list2, menu));
			}

			public void AddOrModifyValue(string name, string value, string menu = null)
			{
				Spec spec = FindFirst(name);
				if (spec == null)
				{
					specs.Add(new Spec(name, value, new List<SpecPair>
					{
						new SpecPair("type", "value")
					}, menu));
				}
				else
				{
					spec.formula = value;
				}
			}

			public string Resolve(string formula, int replacements = 0)
			{
				LoggingPlugin.LogTrace("Processing Resolve: Formula=" + (formula ?? "Empty Formula") + ", Max Replacements=" + replacements);
				if (formula == null || formula.Trim() == "")
				{
					return "";
				}
				int num = 0;
				string text = "";
				for (int i = 0; i < nestedResolve; i++)
				{
					foreach (Spec spec in specs)
					{
						foreach (SpecPair item in spec.extra)
						{
							LoggingPlugin.LogTrace("Processing Resolve: Replacing [" + spec.name + "." + item.key + "] With " + item.value);
							text = formula;
							formula = formula.Replace("[" + spec.name + "." + item.key + "]", item.value);
							if (text != formula)
							{
								num++;
							}
							if (replacements > 0 && num >= replacements)
							{
								LoggingPlugin.LogTrace("Processing Resolve: Max Replacement " + replacements + " Resolve: " + formula);
								return formula;
							}
							LoggingPlugin.LogTrace("Processing Resolve: Formula=" + formula + ", Replacements Count=" + num);
						}
						LoggingPlugin.LogTrace("Processing Resolve: Replacing [" + spec.name + "] With " + spec.formula.ToString());
						text = formula;
						formula = formula.Replace("[" + spec.name + "]", spec.formula.ToString());
						formula = formula.Replace("+-", "-").Replace("-+", "-").Replace("--", "+")
							.Replace("++", "+");
						if (text != formula)
						{
							num++;
						}
						if (replacements > 0 && num >= replacements)
						{
							LoggingPlugin.LogTrace("Processing Resolve: Max Replacement " + replacements + " Resolve: " + formula);
							return formula;
						}
						LoggingPlugin.LogTrace("Processing Resolve: Formula=" + formula + ", Replacements Count=" + num);
					}
				}
				LoggingPlugin.LogTrace("Processing Resolve: Full Resolve: " + formula);
				return formula;
			}

			public Spec[] Find(string whereClause)
			{
				if (specs == null || specs.Count == 0 || string.IsNullOrWhiteSpace(whereClause))
				{
					return null;
				}
				if (whereClause.IndexOf("=") < 0 && whereClause.IndexOf("<") < 0 && whereClause.IndexOf(">") < 0)
				{
					whereClause = "name==\"" + whereClause + "\"";
				}
				LoggingPlugin.LogTrace("Find: " + whereClause);
				return DynamicQueryableExtensions.Where<Spec>(specs.AsQueryable(), whereClause, Array.Empty<object>()).ToArray();
			}

			public Spec FindFirst(string whereClause)
			{
				Spec[] array = Find(whereClause);
				LoggingPlugin.LogTrace("FindFirst: " + ((array != null) ? array.Length.ToString() : "0") + " Matches");
				return (array != null && array.Count() > 0) ? array[0] : null;
			}

			public string FindFirstValue(string whereClause)
			{
				Spec spec = FindFirst(whereClause);
				LoggingPlugin.LogTrace("FindFirstValue: " + ((spec != null) ? (spec.name + "=" + spec.formula) : "Null"));
				return (spec != null) ? spec.formula : "";
			}

			public string FindFirstExtraValue(string whereClause, string property)
			{
				Spec spec = FindFirst(whereClause);
				return (spec != null) ? spec.extra.Where((SpecPair p) => p.key == property).FirstOrDefault().value : "";
			}

			public CreatureBoardAsset FindAsset()
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return ((IEnumerable<CreatureBoardAsset>)(object)CreaturePresenter.GetTempReadOnlyViewOfAllCreatureAssets()).Where((CreatureBoardAsset a) => a.Name.Contains(name)).FirstOrDefault();
			}

			public CreatureBoardAsset[] FindAssets()
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return ((IEnumerable<CreatureBoardAsset>)(object)CreaturePresenter.GetTempReadOnlyViewOfAllCreatureAssets()).Where((CreatureBoardAsset a) => a.Name.Contains(name)).ToArray();
			}
		}

		public class CharactersSpecs
		{
			public enum CheckType
			{
				Regular = 1,
				Opposed,
				Attack,
				Damage,
				Effect,
				Heal,
				Generic
			}

			private List<CharacterSpecs> sheets = new List<CharacterSpecs>();

			private List<string> builtPaths = new List<string>();

			public static Sprite fallbackSprite = Image.LoadSprite("org.lordashes.plugins.d20.character.png", (CacheType)999);

			public List<CharacterSpecs> All()
			{
				return sheets;
			}

			public void Add(CharacterSpecs specs)
			{
				sheets.Add(specs);
			}

			public void Remove(string name)
			{
				for (int i = 0; i < sheets.Count; i++)
				{
					if (sheets[i].name == name)
					{
						sheets.RemoveAt(i);
						i--;
					}
				}
			}

			public void LoadCharacters(bool reload = false)
			{
				//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_00ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
				//IL_011c: Expected O, but got Unknown
				sheets.Clear();
				builtPaths.Clear();
				string[] array = File.Find("org.lordashes.plugins.d20.character.", (CacheType)999);
				foreach (string text in array)
				{
					if (text.ToLower().EndsWith(".json"))
					{
						LoadCharacter(text);
					}
				}
				LoggingPlugin.LogInfo("Loaded " + _self.characters.sheets.Count + " Character Sheets");
				if (!reload)
				{
					RadialUIPlugin.AddCustomButtonOnCharacter("org.lordashes.plugins.d20", new ItemArgs
					{
						Action = delegate
						{
							//IL_000e: Unknown result type (might be due to invalid IL or missing references)
							LoggingPlugin.LogTrace("Selected Character Menu. Triggering Deep Menu...");
							CreatureBoardAsset val = null;
							CreaturePresenter.TryGetAsset(LocalClient.SelectedCreatureId, ref val);
							DeepMenusPlugin.NavigateTo(DiceRoller.StripTrailingInteger(val.Name));
						},
						CloseMenuOnActivate = true,
						FadeName = true,
						Icon = LoadSpriteOrDefault("org.lordashes.plugins.d20.character.png", fallbackSprite),
						Title = "Actions"
					}, (Func<NGuid, NGuid, bool>)delegate
					{
						//IL_000e: Unknown result type (might be due to invalid IL or missing references)
						CreatureBoardAsset instigator = null;
						CreaturePresenter.TryGetAsset(LocalClient.SelectedCreatureId, ref instigator);
						if ((Object)(object)instigator != (Object)null)
						{
							LoggingPlugin.LogDebug("Looking for Sheet For '" + DiceRoller.StripTrailingInteger(instigator.Name) + "'");
							return _self.characters.sheets.Any((CharacterSpecs c) => c.name == DiceRoller.StripTrailingInteger(instigator.Name));
						}
						return false;
					});
				}
				foreach (CharacterSpecs character in sheets)
				{
					DeepMenusPlugin._self.CreateSubMenuItem("/" + character.name, DeepMenusPlugin._self.MakeItemEntry("Edit", (Action<string, string>)delegate
					{
						LoadUserSettings(_self.characters.FindFirst(character.name));
						menuEditOpen = true;
						GameInputEnabled(!menuEditOpen);
					}, LoadSpriteOrDefault("org.lordashes.plugins.d20.edit.png", fallbackSprite), false, true), (Func<bool>)(() => true));
					foreach (Spec spec in character.specs)
					{
						LoggingPlugin.LogTrace("Considering Entry " + spec.name + " (" + spec.menu + ")");
						if (spec.menu != null && spec.menu.Trim() != "")
						{
							BuildMenu(character.name, spec.menu);
						}
					}
				}
			}

			private static void LoadCharacter(string characterSheet)
			{
				string text = File.ReadAllText(characterSheet, (CacheType)999);
				text = text.TrimStart('\ufeff', '\u200b');
				LoggingPlugin.LogInfo("Loading Character Sheet From " + characterSheet);
				try
				{
					CharacterSpecs characterSpecs = JsonConvert.DeserializeObject<CharacterSpecs>(text);
					string characterName = characterSpecs.name;
					if (!_self.characters.All().Any((CharacterSpecs cs) => cs.name == characterName))
					{
						_self.characters.Add(characterSpecs);
						if (characterSpecs.chainSources == null || !(characterSpecs.chainSources != ""))
						{
							return;
						}
						LoggingPlugin.LogDebug("Chain Loading Set To " + characterSpecs.chainSources);
						string[] array = characterSpecs.chainSources.Split(new char[1] { ',' });
						string[] array2 = array;
						foreach (string text2 in array2)
						{
							LoggingPlugin.LogDebug("Chain Loading org.lordashes.plugins.d20.character." + text2);
							LoggingPlugin.LogDebug(JsonConvert.SerializeObject((object)_self.characters));
							CharacterSpecs characterSpecs2 = _self.characters.FindFirst(DiceRoller.StripTrailingInteger(characterName));
							text = File.ReadAllText("org.lordashes.plugins.d20.common." + text2, (CacheType)999);
							text = text.TrimStart('\ufeff', '\u200b');
							characterSpecs = JsonConvert.DeserializeObject<CharacterSpecs>(text);
							foreach (Spec spec in characterSpecs.specs)
							{
								characterSpecs2.specs.Add(spec);
							}
						}
					}
					else
					{
						LoggingPlugin.LogWarning("Duplicated Character Sheet For '" + characterName + "'");
						SystemMessage.DisplayInfoText("D20 Plugin:\r\nDuplicate Character " + characterName, 2.5f, 0f, (Action)null);
					}
				}
				catch (Exception ex)
				{
					string fileName = Path.GetFileName(characterSheet);
					if (ex.Message.IndexOf("line") > -1)
					{
						string text3 = ex.Message.Substring(ex.Message.IndexOf("line") + 4).Trim();
						text3 = text3.Substring(0, text3.IndexOf(",")).Trim();
						LoggingPlugin.LogError("Error On Line " + text3.Substring(1) + " Of " + fileName + " (" + ex.Message + ")");
						try
						{
							int num = int.Parse(text3);
							string[] array3 = text.Split(new string[1] { "\r\n" }, StringSplitOptions.None);
							LoggingPlugin.LogError("Problem Line: " + array3[num].Trim());
						}
						catch (Exception ex2)
						{
							LoggingPlugin.LogError("'" + text3 + "'");
							LoggingPlugin.LogError(ex2.Message);
						}
					}
					else
					{
						LoggingPlugin.LogError(ex.Message);
					}
					string[] source = text.Split(new string[1] { "\r\n" }, StringSplitOptions.None);
					string text4 = string.Join("\r\n", source.Select((string line, int index) => $"Line {index + 1:0000}: {line}"));
					LoggingPlugin.LogInfo("Fault JSON:\r\n" + text4);
				}
			}

			public CharacterSpecs[] Find(string name)
			{
				if (name == "")
				{
					return null;
				}
				return DynamicQueryableExtensions.Where<CharacterSpecs>(sheets.AsQueryable(), "name==\"" + name + "\"", Array.Empty<object>()).ToArray();
			}

			public CharacterSpecs FindFirst(string name)
			{
				if (name == "")
				{
					return null;
				}
				return DynamicQueryableExtensions.Where<CharacterSpecs>(sheets.AsQueryable(), "name==\"" + name + "\"", Array.Empty<object>()).FirstOrDefault();
			}

			public string FindValue(string name, string whereClause)
			{
				return FindFirst(name)?.FindFirstValue(whereClause);
			}

			public static Sprite LoadSpriteOrDefault(string seekSprite, Sprite fallBackSprite)
			{
				if (File.Find(seekSprite, (CacheType)999).Any())
				{
					return Image.LoadSprite(seekSprite, (CacheType)999);
				}
				return fallBackSprite;
			}

			private void BuildMenu(string characterName, string menu)
			{
				menu = "/" + characterName + menu;
				string text = menu.Substring(menu.LastIndexOf("/") + 1);
				string text2 = menu.Substring(0, menu.LastIndexOf("/"));
				string[] array = text2.Substring(1).Split(new char[1] { '/' });
				string text3 = "";
				for (int j = 0; j < array.Length; j++)
				{
					if (!builtPaths.Contains(text3 + ":" + array[j]))
					{
						LoggingPlugin.LogDebug("Building Path " + text3 + "/" + array[j]);
						DeepMenusPlugin._self.CreateSubMenu(text3, DeepMenusPlugin._self.MakeSubMenuEntry(array[j], (text3 != "") ? LoadSpriteOrDefault("org.lordashes.plugins.d20." + array[j] + ".png", fallbackSprite) : null, false, true), (Func<bool>)(() => true));
						builtPaths.Add(text3 + ":" + array[j]);
					}
					text3 = text3 + "/" + array[j];
				}
				LoggingPlugin.LogDebug("Building Leaf " + text3 + "/" + text);
				DeepMenusPlugin._self.CreateSubMenuItem(text3, DeepMenusPlugin._self.MakeItemEntry(text, (Action<string, string>)delegate(string i, string m)
				{
					((MonoBehaviour)_self).StartCoroutine(InitiateMenuAction(i, m));
				}, LoadSpriteOrDefault("org.lordashes.plugins.d20." + text + ".png", fallbackSprite), false, true), (Func<bool>)(() => true));
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass7_0
		{
			public string menu;

			public string item;

			public Func<Spec, bool> <>9__3;

			public Func<Spec, bool> <>9__4;

			public Func<Spec, bool> <>9__5;

			public Func<Spec, bool> <>9__6;

			public Func<Spec, bool> <>9__7;

			internal bool <InitiateMenuAction>b__3(Spec s)
			{
				return s.menu == menu + "/" + item;
			}

			internal bool <InitiateMenuAction>b__4(Spec s)
			{
				return s.menu == menu + "/" + item;
			}

			internal bool <InitiateMenuAction>b__5(Spec s)
			{
				return s.menu == menu + "/" + item;
			}

			internal bool <InitiateMenuAction>b__6(Spec s)
			{
				return s.menu == menu + "/" + item;
			}

			internal bool <InitiateMenuAction>b__7(Spec s)
			{
				return s.menu == menu + "/" + item;
			}
		}

		[CompilerGenerated]
		private sealed class <InitiateMenuAction>d__7 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public string item;

			public string menu;

			public CreatureBoardAsset[] instigators;

			public CreatureBoardAsset[] targets;

			private <>c__DisplayClass7_0 <>8__1;

			private CreatureGuid[] <selectedAssetsIds>5__2;

			private CreatureBoardAsset[] <>s__3;

			private int <>s__4;

			private CreatureBoardAsset <instigator>5__5;

			private CharacterSpecs <stack>5__6;

			private CharacterSpecs <sheet>5__7;

			private Spec <spec>5__8;

			private string <action>5__9;

			private string <publicityStr>5__10;

			private Scripts.MessagePublicity <publicity>5__11;

			private string <>s__12;

			private string <opposed>5__13;

			private int <expectedTargets>5__14;

			private string <>s__15;

			private CreatureBoardAsset <targetAsset>5__16;

			private string <t>5__17;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <InitiateMenuAction>d__7(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<selectedAssetsIds>5__2 = null;
				<>s__3 = null;
				<instigator>5__5 = null;
				<stack>5__6 = null;
				<sheet>5__7 = null;
				<spec>5__8 = null;
				<action>5__9 = null;
				<publicityStr>5__10 = null;
				<>s__12 = null;
				<opposed>5__13 = null;
				<>s__15 = null;
				<targetAsset>5__16 = null;
				<t>5__17 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f5: Expected O, but got Unknown
				//IL_014f: 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_0707: Unknown result type (might be due to invalid IL or missing references)
				//IL_070c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0711: Unknown result type (might be due to invalid IL or missing references)
				//IL_0785: Unknown result type (might be due to invalid IL or missing references)
				//IL_078a: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass7_0();
					<>8__1.menu = menu;
					<>8__1.item = item;
					LoggingPlugin.LogDebug("---[ACTION SELECTED: " + <>8__1.item + " (" + <>8__1.menu + ")]---");
					((MonoBehaviour)_self).StartCoroutine(PatchCallCameraClick.preventClickCollection(1f));
					<>2__current = (object)new WaitForSeconds(0.1f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<selectedAssetsIds>5__2 = null;
					LocalClient.TryGetLassoedCreatureIds(ref <selectedAssetsIds>5__2);
					if (<selectedAssetsIds>5__2 == null)
					{
						instigators = GetCreatureAssets(<selectedAssetsIds>5__2);
					}
					if (<selectedAssetsIds>5__2 == null)
					{
						instigators = GetCreatureAssets((CreatureGuid[])(object)new CreatureGuid[1] { LocalClient.SelectedCreatureId });
					}
					if (targets == null)
					{
						targets = GetAffectedCreatures();
					}
					LoggingPlugin.LogDebug("Instagators (" + instigators.Length + ") = " + string.Join(",", instigators.Select((CreatureBoardAsset a) => a.Name)));
					LoggingPlugin.LogDebug("Targets (" + targets.Length + ") = " + string.Join(",", targets.Select((CreatureBoardAsset a) => a.Name)));
					<>8__1.menu = <>8__1.menu.Substring(1);
					<>8__1.menu = <>8__1.menu.Substring(<>8__1.menu.IndexOf("/"));
					<>s__3 = instigators;
					<>s__4 = 0;
					goto IL_0e5f;
				case 2:
					<>1__state = -1;
					<targetAsset>5__16 = null;
					goto IL_0e16;
				case 3:
					<>1__state = -1;
					goto IL_0e16;
				case 4:
					<>1__state = -1;
					goto IL_0e16;
				case 5:
					<>1__state = -1;
					goto IL_0e16;
				case 6:
					<>1__state = -1;
					goto IL_0e16;
				case 7:
					{
						<>1__state = -1;
						goto IL_0e16;
					}
					IL_0e2c:
					<stack>5__6 = null;
					<sheet>5__7 = null;
					<spec>5__8 = null;
					<action>5__9 = null;
					goto IL_0e49;
					IL_0e16:
					<opposed>5__13 = null;
					<>s__15 = null;
					<publicityStr>5__10 = null;
					goto IL_0e2c;
					IL_0e49:
					<instigator>5__5 = null;
					<>s__4++;
					goto IL_0e5f;
					IL_0e5f:
					if (<>s__4 < <>s__3.Length)
					{
						<instigator>5__5 = <>s__3[<>s__4];
						LoggingPlugin.LogDebug("Current Pass Instinagtor: " + <instigator>5__5.Name);
						LoggingPlugin.LogDebug("Current Targets (" + targets.Length + ") = " + string.Join(",", targets.Select((CreatureBoardAsset a) => a.Name)));
						if ((Object)(object)<instigator>5__5 != (Object)null)
						{
							<stack>5__6 = new CharacterSpecs();
							<sheet>5__7 = _self.characters.FindFirst(DiceRoller.StripTrailingInteger(<instigator>5__5.Name));
							<spec>5__8 = null;
							<action>5__9 = <sheet>5__7.FindFirstExtraValue("menu==\"" + <>8__1.menu + "/" + <>8__1.item + "\"", "type");
							LoggingPlugin.LogDebug("Action: " + ((<action>5__9 != null) ? <action>5__9 : "Null"));
							if (<action>5__9 == null || <action>5__9.Trim() == "")
							{
								<action>5__9 = "skill";
							}
							<spec>5__8 = <sheet>5__7.specs.Where((Spec s) => s.menu == <>8__1.menu + "/" + <>8__1.item).FirstOrDefault();
							if (<spec>5__8 != null)
							{
								LoggingPlugin.LogTrace("Getting Publicity");
								<publicityStr>5__10 = <spec>5__8.Extra("message");
								<publicity>5__11 = Scripts.MessagePublicity.publicMessage;
								string text = <publicityStr>5__10;
								<>s__12 = text;
								string text2 = <>s__12;
								if (!(text2 == "private"))
								{
									if (text2 == "semiprivate")
									{
										<publicity>5__11 = Scripts.MessagePublicity.semiPrivateMessage;
									}
									else
									{
										<publicity>5__11 = Scripts.MessagePublicity.publicMessage;
									}
								}
								else
								{
									<publicity>5__11 = Scripts.MessagePublicity.privateMessage;
								}
								<>s__12 = null;
								string text3 = <action>5__9;
								<>s__15 = text3;
								switch (<>s__15)
								{
								case "info":
								case "skill":
								case "attack":
								case "save":
								case "spell":
									break;
								case "effect":
									<spec>5__8 = <sheet>5__7.specs.Where((Spec s) => s.menu == <>8__1.menu + "/" + <>8__1.item).FirstOrDefault();
									LoggingPlugin.LogDebug("Found Spec: " + (<spec>5__8 != null));
									LoggingPlugin.LogDebug("Processing " + <instigator>5__5.Name + "'s " + <>8__1.item + " (" + <action>5__9 + ") As Damage");
									<>2__current = Scripts.ProcessEffectOnTarget(<stack>5__6, CharactersSpecs.CheckType.Effect, <spec>5__8, <instigator>5__5, (targets.Length != 0) ? targets[0] : <instigator>5__5, "Hit", <publicity>5__11, <spec>5__8.name);
									<>1__state = 4;
									return true;
								case "damage":
									<spec>5__8 = <sheet>5__7.specs.Where((Spec s) => s.menu == <>8__1.menu + "/" + <>8__1.item).FirstOrDefault();
									LoggingPlugin.LogDebug("Found Spec: " + (<spec>5__8 != null));
									LoggingPlugin.LogDebug("Processing " + <instigator>5__5.Name + "'s " + <>8__1.item + " (" + <action>5__9 + ") As Damage");
									<>2__current = Scripts.ProcessDamageOnTarget(<stack>5__6, CharactersSpecs.CheckType.Damage, <spec>5__8, <instigator>5__5, (targets.Length != 0) ? targets[0] : <instigator>5__5, "Hit", <publicity>5__11, <spec>5__8.name);
									<>1__state = 5;
									return true;
								case "heal":
									<spec>5__8 = <sheet>5__7.specs.Where((Spec s) => s.menu == <>8__1.menu + "/" + <>8__1.item).FirstOrDefault();
									LoggingPlugin.LogDebug("Found Spec: " + (<spec>5__8 != null));
									LoggingPlugin.LogDebug("Processing " + <instigator>5__5.Name + "'s " + <>8__1.item + " (" + <action>5__9 + ") As Heal");
									<>2__current = Scripts.ProcessHealOnTarget(<stack>5__6, CharactersSpecs.CheckType.Heal, <spec>5__8, <instigator>5__5, (targets.Length != 0) ? targets[0] : <instigator>5__5, <publicity>5__11);
									<>1__state = 6;
									return true;
								default:
									<spec>5__8 = <sheet>5__7.specs.Where((Spec s) => s.menu == <>8__1.menu + "/" + <>8__1.item).FirstOrDefault();
									LoggingPlugin.LogDebug("Found Spec: " + (<spec>5__8 != null));
									LoggingPlugin.LogDebug("Processing " + <instigator>5__5.Name + "'s " + <>8__1.item + " (" + <action>5__9 + ") As Generic");
									<>2__current = Scripts.ProcessGeneric(<stack>5__6, CharactersSpecs.CheckType.Generic, <spec>5__8, <instigator>5__5, (targets.Length != 0) ? targets[0] : <instigator>5__5, <publicity>5__11);
									<>1__state = 7;
									return true;
								}
								LoggingPlugin.LogDebug("Found Spec: " + (<spec>5__8 != null));
								<opposed>5__13 = <spec>5__8.Extra("opposed");
								LoggingPlugin.LogDebug("Found Opposed: " + (<opposed>5__13 != null));
								<expectedTargets>5__14 = ((<spec>5__8.Extra("targets") != null) ? int.Parse(<spec>5__8.Extra("targets")) : 0);
								LoggingPlugin.LogDebug("Expected Targets: " + <expectedTargets>5__14);
								if (<opposed>5__13 != null && <opposed>5__13 != "" && new CreatureGuid(RadialUIPlugin.GetLastRadialTargetCreature()) != LocalClient.SelectedCreatureId)
								{
									LoggingPlugin.LogDebug("Processing " + <instigator>5__5.Name + "'s " + <>8__1.item + " (" + <action>5__9 + ") As Opposed Skill With Selected Target.");
									<targetAsset>5__16 = null;
									CreaturePresenter.TryGetAsset(new CreatureGuid(RadialUIPlugin.GetLastRadialTargetCreature()), ref <targetAsset>5__16);
									<>2__current = Scripts.ProcessSequence(<stack>5__6, (<action>5__9 == "attack" || <action>5__9 == "spell") ? CharactersSpecs.CheckType.Attack : CharactersSpecs.CheckType.Opposed, <spec>5__8, <instigator>5__5, (CreatureBoardAsset[])(object)new CreatureBoardAsset[1] { <targetAsset>5__16 }, <publicity>5__11);
									<>1__state = 2;
									return true;
								}
								if (<opposed>5__13 != null && <opposed>5__13 != "")
								{
									LoggingPlugin.LogDebug("Processing " + <instigator>5__5.Name + "'s " + <>8__1.item + " (" + <action>5__9 + ") As Opposed Skill. Collecting Targets.");
									TargetsCollection obj = new TargetsCollection
									{
										targetsCollectingSpecType = <action>5__9,
										targetsCollectingSpec = <spec>5__8,
										targetsCollectingInstigator = <instigator>5__5,
										targetsCollectingPublicity = <publicity>5__11
									};
									<t>5__17 = <spec>5__8.Extra("targets");
									obj.targetsCollecting = int.Parse((<t>5__17 != null) ? <t>5__17 : int.MaxValue.ToString());
									targetsCollection = obj;
									<t>5__17 = null;
									goto IL_0e16;
								}
								LoggingPlugin.LogDebug("Processing " + <instigator>5__5.Name + "'s " + <>8__1.item + " (" + <action>5__9 + ") As Skill");
								<>2__current = Scripts.ProcessSequence(<stack>5__6, CharactersSpecs.CheckType.Regular, <spec>5__8, <instigator>5__5, null, <publicity>5__11);
								<>1__state = 3;
								return true;
							}
							goto IL_0e2c;
						}
						goto IL_0e49;
					}
					<>s__3 = null;
					LoggingPlugin.LogDebug("Action Processing Completed");
					return false;
				}
			}

			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 static CreatureBoardAsset[] GetCreatureAssets(CreatureGuid[] cids)
		{
			//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_0024: Unknown result type (might be due to invalid IL or missing references)
			List<CreatureBoardAsset> list = new List<CreatureBoardAsset>();
			if (cids != null)
			{
				foreach (CreatureGuid val in cids)
				{
					CreatureBoardAsset val2 = null;
					CreaturePresenter.TryGetAsset(val, ref val2);
					if ((Object)(object)val2 != (Object)null)
					{
						list.Add(val2);
					}
				}
			}
			return list.ToArray();
		}

		public static string[] GetCreatureNames(CreatureGuid[] cids)
		{
			return (from a in GetCreatureAssets(cids)
				select a.Name).ToArray();
		}

		private static CreatureBoardAsset[] GetAffectedCreatures()
		{
			//IL_004d: 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_0115: 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)
			List<CreatureBoardAsset> list = new List<CreatureBoardAsset>();
			FieldInfo fieldInfo = (from i in typeof(CreatureBoardAsset).GetRuntimeFields()
				where i.Name == "_selected"
				select i).FirstOrDefault();
			if (fieldInfo != null)
			{
				foreach (CreatureBoardAsset item2 in (IEnumerable<CreatureBoardAsset>)CreaturePresenter.GetTempReadOnlyViewOfAllCreatureAssets())
				{
					if ((Object)(object)item2 != (Object)null && (bool)fieldInfo.GetValue(item2))
					{
						list.Add(item2);
					}
				}
			}
			if (!list.Any((CreatureBoardAsset c) => c.CreatureId == new CreatureGuid(RadialUIPlugin.GetLastRadialTargetCreature())))
			{
				CreatureBoardAsset val = null;
				CreaturePresenter.TryGetAsset(new CreatureGuid(RadialUIPlugin.GetLastRadialTargetCreature()), ref val);
				if ((Object)(object)val != (Object)null)
				{
					list.Add(val);
				}
			}
			CreatureBoardAsset item = default(CreatureBoardAsset);
			CreaturePresenter.TryGetAsset(LocalClient.SelectedCreatureId, ref item);
			if (list.Contains(item))
			{
				list.Remove(item);
			}
			return list.ToArray();
		}

		[IteratorStateMachine(typeof(<InitiateMenuAction>d__7))]
		public static IEnumerator InitiateMenuAction(string item, string menu, CreatureBoardAsset[] instigators = null, CreatureBoardAsset[] targets = null)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <InitiateMenuAction>d__7(0)
			{
				item = item,
				menu = menu,
				instigators = instigators,
				targets = targets
			};
		}
	}

	public static class DiceRoller
	{
		public class RollResult
		{
			public string name { get; set; }

			public string formula { get; set; }

			public string formulaResolved { get; set; }

			public string formulaDice { get; set; }

			public int total { get; set; }

			public int[] dice { get; set; }
		}

		public enum RollingMethod
		{
			randomGeneratorDice = 1,
			talespireDice
		}

		public static class RollSimplifier
		{
			public class RollParseResult
			{
				public string RollString { get; set; }

				public List<short> AllDiceValues { get; set; }

				public List<int> Totals { get; set; }
			}

			public static RollParseResult ParseRollResults(RollResults rollResults)
			{
				//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_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				List<short> allDiceValues = new List<short>();
				List<string> list = new List<string>();
				List<int> list2 = new List<int>();
				RollGroup[] array = rollResults.ResultsGroups.ToArray();
				foreach (RollGroup val in array)
				{
					var (item, item2) = ProcessOperand(val.Result, allDiceValues);
					list.Add(item);
					list2.Add(item2);
				}
				return new RollParseResult
				{
					RollString = string.Join(" / ", list),
					AllDiceValues = allDiceValues,
					Totals = list2
				};
			}

			private static (string str, int total) ProcessOperand(RollOperand operand, List<short> allDiceValues)
			{
				//IL_0009: 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_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: 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_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: 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_001b: Invalid comparison between Unknown and I8
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_0101: Unknown result type (might be due to invalid IL or missing references)
				//IL_015e: Unknown result type (might be due to invalid IL or missing references)
				//IL_016d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: 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)
				//IL_0082: 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_00ac: 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)
				RollOperation val = default(RollOperation);
				RollResult val2 = default(RollResult);
				RollValue val3 = default(RollValue);
				Which val4 = ((RollOperand)(ref operand)).Get(ref val, ref val2, ref val3);
				Which val5 = val4;
				Which val6 = val5;
				if ((long)val6 <= 2L)
				{
					switch ((uint)val6)
					{
					case 0u:
					{
						RollOperand[] array2 = val.Operands.ToArray();
						if (array2.Length != 2)
						{
							throw new InvalidOperationException("Unexpected number of operands in RollOperation (expected 2).");
						}
						(string, int) tuple = ProcessOperand(array2[0], allDiceValues);
						(string, int) tuple2 = ProcessOperand(array2[1], allDiceValues);
						int item2 = (((int)val.Operator == 0) ? (tuple.Item2 + tuple2.Item2) : (tuple.Item2 - tuple2.Item2));
						string text = (((int)val.Operator == 0) ? "+" : "-");
						return (tuple.Item1 + text + tuple2.Item1, item2);
					}
					case 1u:
					{
						int num = ((IEnumerable<short>)val2.Results).Count();
						string registeredName = ((DieKind)(ref val2.Kind)).RegisteredName;
						short[] array = val2.Results.ToArray();
						allDiceValues.AddRange(array);
						int item = array.Sum((short r) => r);
						return ($"{num}{registeredName}", item);
					}
					case 2u:
					{
						short value = val3.Value;
						return (value.ToString(), val3.Value);
					}
					}
				}
				throw new InvalidOperationException("Unknown RollOperand type encountered.");
			}
		}

		private static readonly Random _rng = new Random();

		private static readonly Regex TokenRegex = new Regex("(\\d+[dD]\\d+[aAdD]?|\\d+|[+\\-*/])", RegexOptions.Compiled);

		private static readonly Regex DiceRegex = new Regex("(\\d+)[dD](\\d+)([aAdD]?)", RegexOptions.Compiled);

		private static readonly string TermPattern = "(?:\\d+[dD]\\d+[aAdD]?|\\d+|[A-Za-z_][A-Za-z0-9_]*)";

		public static TaskCompletionSource<RollResult> pendingRoll;

		public static async Task<RollResult> Roll(Characters.CharacterSpecs instigatorSheet, string rollName, string expression, RollingMethod? rollingStyle = null)
		{
			RollingMethod useRollingStyle = (rollingStyle.HasValue ? rollingStyle.Value : rollingStyleOffensive);
			RollResult rollResult = new RollResult
			{
				name = rollName,
				formula = expression,
				formulaResolved = SimplifyExpression(ComputeConstants(instigatorSheet.Resolve(expression)))
			};
			RollResult rawRollResult;
			switch (useRollingStyle)
			{
			case RollingMethod.randomGeneratorDice:
				rawRollResult = RollRandomGeneratorDice(instigatorSheet, rollResult.formulaResolved);
				break;
			case RollingMethod.talespireDice:
			{
				string justDice = ExtractTalespireDiceRolls(rollResult.formulaResolved);
				rawRollResult = ((!(justDice.Trim() != "")) ? new RollResult
				{
					dice = new int[0]
				} : (await RollTalespireDice(instigatorSheet, rollName, justDice.Trim())));
				break;
			}
			default:
				return null;
			}
			rollResult.formulaDice = ResolveDiceValues(rollResult.formulaResolved, rawRollResult.dice);
			rollResult.total = ResolveTotal(rollResult.formulaResolved, rawRollResult.dice);
			rollResult.dice = rawRollResult.dice;
			LoggingPlugin.LogDebug("Dice Roller: Name: " + rollResult.name);
			LoggingPlugin.LogDebug("Dice Roller: Formula: " + rollResult.formula);
			LoggingPlugin.LogDebug("Dice Roller: Roll: " + rollResult.formulaResolved);
			LoggingPlugin.LogDebug("Dice Roller: Dice: " + rollResult.formulaDice);
			LoggingPlugin.LogDebug("Dice Roller: Total: " + rollResult.total);
			return rollResult;
		}

		public static Task<RollResult> RollTalespireDice(Characters.CharacterSpecs instigatorSheet, string rollName, string expression)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			LoggingPlugin.LogDebug("Using Talespire Dice");
			if (pendingRoll != null)
			{
				throw new InvalidOperationException("A virtual dice roll is already in progress.");
			}
			LoggingPlugin.LogDebug("Setting Dice Expecting Flag");
			pendingRoll = new TaskCompletionSource<RollResult>();
			string text = "talespire://dice/" + rollName + ":" + expression;
			LoggingPlugin.LogDebug("Requesting: " + text);
			LocalConnectionManager.ProcessTaleSpireUrl(text);
			return pendingRoll.Task;
		}

		public static RollResult RollRandomGeneratorDice(Characters.CharacterSpecs instigatorSheet, string expression)
		{
			LoggingPlugin.LogDebug("Using Random Generator Dice");
			if (string.IsNullOrWhiteSpace(expression))
			{
				throw new ArgumentException("Expression cannot be empty.");
			}
			List<int> diceRolls = new List<int>();
			string expression2 = DiceRegex.Replace(expression, delegate(Match match)
			{
				int count = int.Parse(match.Groups[1].Value);
				int sides = int.Parse(match.Groups[2].Value);
				char c = ((match.Groups[3].Value.Length > 0) ? char.ToUpperInvariant(match.Groups[3].Value[0]) : '\0');
				if (c == '\0')
				{
					return RollOnce().ToString();
				}
				int val = RollOnce();
				int val2 = RollOnce();
				return ((c == 'A') ? Math.Max(val, val2) : Math.Min(val, val2)).ToString();
			});
			int total = EvaluateIntegerExpression(expression2);
			return new RollResult
			{
				formula = expression,
				formulaResolved = SimplifyExpression(ComputeConstants(instigatorSheet.Resolve(expression))),
				formulaDice = SimplifyExpression(ResolveDiceValues(ComputeConstants(instigatorSheet.Resolve(expression)), diceRolls.ToArray())),
				total = total,
				dice = diceRolls.ToArray()
			};
			int RollOnce()
			{
				int num = 0;
				for (int i = 0; i < P_0.count; i++)
				{
					int num2 = _rng.Next(1, P_0.sides + 1);
					diceRolls.Add(num2);
					num += num2;
				}
				return num;
			}
		}

		public static string ResolveDiceValues(string formula, int[] dice)
		{
			if (string.IsNullOrWhiteSpace(formula))
			{
				throw new ArgumentException("Expression cannot be empty.");
			}
			if (dice == null)
			{
				throw new ArgumentNullException("dice");
			}
			int num = 0;
			StringBuilder stringBuilder = new StringBuilder();
			int num2 = 0;
			foreach (Match item in DiceRegex.Matches(formula))
			{
				stringBuilder.Append(formula.Substring(num2, item.Index - num2));
				int num3 = int.Parse(item.Groups[1].Value);
				char c = ((item.Groups[3].Value.Length > 0) ? char.ToUpperInvariant(item.Groups[3].Value[0]) : '\0');
				int num4 = ((c != 'A' && c != 'D') ? 1 : 2);
				int num5 = num3 * num4;
				if (num + num5 > dice.Length)
				{
					throw new ArgumentException("Not enough dice values provided.");
				}
				if (num4 > 1)
				{
					stringBuilder.Append("(");
					for (int i = 0; i < num5; i++)
					{
						if (i > 0)
						{
							stringBuilder.Append(",");
						}
						stringBuilder.Append(dice[num + i]);
					}
					stringBuilder.Append(")");
					stringBuilder.Append(c);
				}
				else if (num3 == 1)
				{
					stringBuilder.Append(dice[num]);
				}
				else
				{
					stringBuilder.Append("(");
					for (int j = 0; j < num3; j++)
					{
						if (j > 0)
						{
							stringBuilder.Append(",");
						}
						stringBuilder.Append(dice[num + j]);
					}
					stringBuilder.Append(")");
				}
				num += num5;
				num2 = item.Index + item.Length;
			}
			stringBuilder.Append(formula.Substring(num2));
			return stringBuilder.ToString();
		}

		public static int ResolveTotal(string formula, int[] dice)
		{
			int num = 0;
			StringBuilder stringBuilder = new StringBuilder();
			foreach (Match item in TokenRegex.Matches(formula))
			{
				string value = item.Value;
				Match match2 = DiceRegex.Match(value);
				if (match2.Success)
				{
					int num2 = int.Parse(match2.Groups[1].Value);
					char c = ((match2.Groups[3].Length > 0) ? char.ToUpperInvariant(match2.Groups[3].Value[0]) : '\0');
					if (c == '\0')
					{
						if (num + num2 > dice.Length)
						{
							throw new ArgumentException("Not enough dice values supplied.");
						}
						int num3 = 0;
						for (int i = 0; i < num2; i++)
						{
							num3 += dice[num++];
						}
						stringBuilder.Append(num3);
						continue;
					}
					int num4 = num2 * 2;
					if (num + num4 > dice.Length)
					{
						throw new ArgumentException("Not enough dice values supplied.");
					}
					int num5 = 0;
					for (int j = 0; j < num2; j++)
					{
						num5 += dice[num++];
					}
					int num6 = 0;
					for (int k = 0; k < num2; k++)
					{
						num6 += dice[num++];
					}
					int value2 = ((c == 'A') ? Math.Max(num5, num6) : Math.Min(num5, num6));
					stringBuilder.Append(value2);
				}
				else
				{
					stringBuilder.Append(value);
				}
			}
			object value3 = new DataTable().Compute(stringBuilder.ToString(), null);
			return Convert.ToInt32(value3);
		}

		public static int ResolveMaxTotal(string expression)
		{
			if (string.IsNullOrWhiteSpace(expression))
			{
				throw new ArgumentException("Expression cannot be empty.");
			}
			List<int> list = new List<int>();
			foreach (Match item2 in DiceRegex.Matches(expression))
			{
				int num = int.Parse(item2.Groups[1].Value);
				int num2 = int.Parse(item2.Groups[2].Value);
				string value = item2.Groups[3].Value;
				int item = num * num2;
				list.Add(item);
				if (!string.IsNullOrEmpty(value))
				{
					list.Add(item);
				}
			}
			return ResolveTotal(expression, list.ToArray());
		}

		public static string ExtractTalespireDiceRolls(string expression)
		{
			Regex regex = new Regex("(?<op>[+\\-*/]?)\\s*(?<dice>\\d+[dD]\\d+)(?<rep>[aAdD]?)|\\d+", RegexOptions.Compiled);
			StringBuilder stringBuilder = new StringBuilder();
			bool flag = true;
			foreach (Match item in regex.Matches(expression))
			{
				if (!item.Groups["dice"].Success)
				{
					continue;
				}
				string value = item.Groups["op"].Value;
				string value2 = item.Groups["dice"].Value;
				string value3 = item.Groups["rep"].Value;
				int num = ((value3.Length <= 0) ? 1 : 2);
				for (int i = 0; i < num; i++)
				{
					if (!flag)
					{
						stringBuilder.Append((value.Length > 0) ? value : "+");
					}
					stringBuilder.Append(value2);
					flag = false;
				}
			}
			return stringBuilder.ToString().Replace("-", "+").Replace("/", "+")
				.Replace("*", "+");
		}

		public static string SimplifyExpression(string formula)
		{
			if (string.IsNullOrWhiteSpace(formula))
			{
				return formula;
			}
			formula = Regex.Replace(formula, "(?<!\\w)(" + TermPattern + ")\\s*\\*\\s*0|0\\s*\\*\\s*(" + TermPattern + ")", "+0");
			formula = Regex.Replace(formula, "(?<!\\w)1\\s*\\*\\s*(" + TermPattern + ")", "$1");
			formula = Regex.Replace(formula, "(" + TermPattern + ")\\s*\\*\\s*1(?!\\w)", "$1");
			formula = Regex.Replace(formula, "\\+\\+", "+");
			formula = Regex.Replace(formula, "\\+-", "-");
			formula = Regex.Replace(formula, "-\\+", "-");
			formula = Regex.Replace(formula, "--", "+");
			formula = Regex.Replace(formula, "^\\+", "");
			return formula;
		}

		public static string StripTrailingInteger(string input)
		{
			if (string.IsNullOrEmpty(input))
			{
				return input;
			}
			return Regex.Replace(input, "(\\(\\d+\\)|\\d+)$", "");
		}

		public static string ComputeConstants(string expression)
		{
			while (expression.Contains("("))
			{
				int startIndex = expression.IndexOf("(");
				string text = expression.Substring(startIndex);
				text = expression.Substring(0, expression.IndexOf(")") + 1);
				string text2 = Compute(text).ToString();
				expression = expression.Replace(text, text2);
				LoggingPlugin.LogDebug("Compute Constants: Replacing '" + text + "' With '" + text2 + "'. Expression is now: " + expression);
			}
			return expression;
		}

		private static string Compute(string expression)
		{
			DataTable dataTable = new DataTable();
			return dataTable.Compute(expression, null).ToString();
		}

		private static int EvaluateIntegerExpression(string expression)
		{
			object value = new DataTable().Compute(expression, null);
			return Convert.ToInt32(value);
		}
	}

	public class TargetsCollection
	{
		public string targetsCollectingSpecType = null;

		public Characters.Spec targetsCollectingSpec = null;

		public CreatureBoardAsset targetsCollectingInstigator;

		public Scripts.MessagePublicity targetsCollectingPublicity = Scripts.MessagePublicity.publicMessage;

		public int targetsCollecting = 0;

		public List<CreatureBoardAsset> targetsCollected = new List<CreatureBoardAsset>();
	}

	[HarmonyPatch(typeof(UI_DiceRollGroup), "DisplayGroup")]
	public static class PatchSetResult
	{
		public static bool Prefix(UI_DiceRollGroup __instance, RollGroup resultsGroup, bool isFirst, TMP_Text ____headerText, FactoryInspectorSetup<UI_DiceOperator> ____operatorFactory, RectTransform ____content, int ____contentGridWrapWidth, GridLayoutGroup ____contentGrid, RectTransform ____transform)
		{
			//IL_0021: 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_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			if (DiceRoller.pendingRoll != null)
			{
				string text = (isFirst ? "Rolled" : "And");
				string name = resultsGroup.Name;
				if (!string.IsNullOrWhiteSpace(name))
				{
					text = text + " " + name;
				}
				____headerText.text = text;
				int num = (int)(from m in typeof(UI_DiceRollGroup).GetRuntimeMethods()
					where m.Name == "DisplayOperand"
					select m).FirstOrDefault().Invoke(__instance, new object[2] { resultsGroup.Result, true });
				UI_DiceOperator val = ____operatorFactory.Hire(true);
				((Component)val).transform.SetAsLastSibling();
				if (((Transform)____content).childCount <= ____contentGridWrapWidth)
				{
					____contentGrid.constraint = (Constraint)2;
					____contentGrid.constraintCount = 1;
					RectTransformExtensions.SetHeight(____transform, 25f + ____contentGrid.cellSize.y);
					return false;
				}
				____contentGrid.constraint = (Constraint)1;
				____contentGrid.constraintCount = ____contentGridWrapWidth;
				float num2 = math.ceil((float)((Transform)____content).childCount / (float)____contentGrid.constraintCount) * (____contentGrid.cellSize.y + ____contentGrid.spacing.y);
				RectTransformExtensions.SetHeight(____transform, 25f + num2);
				return false;
			}
			return true;
		}
	}

	[HarmonyPatch(typeof(GUIManager), "PlayMode_OnStateChange")]
	public static class GUIManagerPlayModeOnStateChange
	{
		public static bool Prefix(State obj)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			if (((object)obj).ToString() == "PlayMode+TurnBased")
			{
				LoggingPlugin.LogDebug("Initiative Mode Selected");
				AssetDataPlugin.SendInfo("org.lordashes.plugins.d20", "action:initiative");
				ChatManager.SendChatMessageToBoard("[Roll Initiative!]\r\nCollecting Initiatives", LocalPlayer.Id.Value, (float3?)null, false);
				initiativeOrder.Clear();
			}
			return true;
		}
	}

	[HarmonyPatch(typeof(UI_InitativeManager), "OpenEdit")]
	public class InitiativeManagerApplyEditPatch
	{
		private static void Postfix(bool value)
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: 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_0113: Unknown result type (might be due to invalid IL or missing references)
			LoggingPlugin.LogDebug("Applying Stored Initiatives");
			InitiativeManager.SetEditQueue(initiativeOrder.Values.ToArray());
			LoggingPlugin.LogDebug("Ending Initiative Collection");
			if (collectingInitiative && summarizeInitiative)
			{
				string text = "";
				foreach (KeyValuePair<int, QueueElement> item in initiativeOrder)
				{
					CreatureBoardAsset val = null;
					CreaturePresenter.TryGetAsset(item.Value.CreatureGuid, ref val);
					if ((Object)(object)val != (Object)null)
					{
						text = text + item.Key + ": " + val.Name + "\r\n";
					}
				}
				if (text != "")
				{
					text = text.Substring(0, text.Length - 2);
					ChatManager.SendChatMessageToBoard("[Initiative]\r\n" + text, LocalPlayer.Id.Value, (float3?)null, false);
				}
			}
			collectingInitiative = false;
		}
	}

	[HarmonyPatch(typeof(UIChatMessageManager), "AddChatMessage")]
	public static class PatchAddMessage
	{
		public static bool Prefix(string creatureName, Texture2D icon, string chatMessage, IChatFocusable focus = null)
		{
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			LoggingPlugin.LogDebug("Initiative Collection: " + collectingInitiative);
			if (collectingInitiative)
			{
				LoggingPlugin.LogDebug("Initiative Collection: Active");
				LoggingPlugin.LogDebug("Initiative Collection: Caption: " + ((creatureName != null) ? creatureName : "None"));
				LoggingPlugin.LogDebug("Initiative Collection: Icon: " + (((Object)(object)icon != (Object)null && ((Object)icon).name != null) ? ((Object)icon).name : "None"));
				LoggingPlugin.LogDebug("Initiative Collection: Message: " + ((chatMessage != null) ? chatMessage.Replace("\r\n", "|") : "None"));
				CreatureBoardAsset val = null;
				CreaturePresenter.TryGetAsset(LocalClient.SelectedCreatureId, ref val);
				if (LocalClient.IsPartyGm)
				{
					LoggingPlugin.LogDebug("Initiative Collection: GM Client");
					try
					{
						string text = chatMessage.Substring(chatMessage.LastIndexOf(" ") + 1);
						LoggingPlugin.LogDebug("Initiative Collection: Adding Roll: " + text + " For " + creatureName);
						initiativeOrder.Add(int.Parse(text), new QueueElement((ElementType)0, LocalClient.SelectedCreatureId));
					}
					catch
					{
						SystemMessage.DisplayInfoText("D20 Plugin:\r\nRoll may be set to value instead of skill.", 2.5f, 0f, (Action)null);
					}
				}
				else
				{
					LoggingPlugin.LogDebug("Initiative Collection: Non-GM Client");
				}
			}
			return true;
		}
	}

	[HarmonyPatch(typeof(UIChatMessageManager), "AddDiceResultMessage")]
	public static class PatchAddDiceResultMessage
	{
		public static bool Prefix(RollResults diceResult, ResultsOrigin origin, ClientGuid sender, bool hidden, IChatFocusable focus = null)
		{
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			if (DiceRoller.pendingRoll != null)
			{
				DiceRoller.RollSimplifier.RollParseResult rollParseResult = DiceRoller.RollSimplifier.ParseRollResults(diceResult);
				int num = rollParseResult.Totals.Sum();
				DiceRoller.RollResult result = new DiceRoller.RollResult
				{
					total = rollParseResult.Totals.Sum(),
					dice = ((IEnumerable<short>)rollParseResult.AllDiceValues).Select((Func<short, int>)((short s) => s)).ToArray()
				};
				DiceRoller.pendingRoll?.TrySetResult(result);
				DiceRoller.pendingRoll = null;
				DiceRollManager val = Object.FindObjectOfType<DiceRollManager>();
				if ((Object)(object)val != (Object)null)
				{
					val.RemoveRoll(diceResult.RollId);
				}
				return false;
			}
			return true;
		}
	}

	[HarmonyPatch(typeof(BoardTool), "CallCameraClick")]
	public static class PatchCallCameraClick
	{
		[CompilerGenerated]
		private sealed class <holdAndClear>d__3 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public float delay;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <holdAndClear>d__3(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_0031: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(delay);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					targetsCollection.targetsCollecting = 0;
					targetsCollection.targetsCollected.Clear();
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <preventClickCollection>d__4 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public float delay;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <preventClickCollection>d__4(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					preventClickCalls = true;
					<>2__current = (object)new WaitForSeconds(delay);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					preventClickCalls = false;
					return false;
				}
			}

			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 static bool preventClickCalls;

		public static bool Prefix(CameraClickEvent click)
		{
			//IL_0047: 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_004d: Unknown result type (might be due to invalid IL or missing references)
			if (!preventClickCalls && targetsCollection.targetsCollecting > 0 && !((object)BoardToolManager.CurrentTool).ToString().Contains("RulerBoardTool"))
			{
				string[] obj = new string[6] { "Generic Click: User Click At ", null, null, null, null, null };
				Vector2 position = click.position;
				obj[1] = ((object)(Vector2)(ref position)).ToString();
				obj[2] = " With Tool ";
				obj[3] = ((object)BoardToolManager.CurrentTool).ToString();
				obj[4] = " And Collecting ";
				obj[5] = collecting;
				LoggingPlugin.LogDebug(string.Concat(obj));
				preventClickCalls = true;
				((MonoBehaviour)_self).StartCoroutine(preventClickCollection(1f));
				CreatureBoardAsset val = null;
				float3 val2 = default(float3);
				PixelPickingManager.TryGetPickedCreature(ref val2, ref val);
				if ((Object)(object)val != (Object)null)
				{
					LoggingPlugin.LogDebug("Generic Click: Added Asset " + val.Name + " At " + ((object)(float3)(ref val2)).ToString());
					targetsCollection.targetsCollected.Add(val);
					if (targetsCollection.targetsCollected.Count >= targetsCollection.targetsCollecting)
					{
						ProcessSelection();
					}
				}
				if (Input.GetMouseButtonDown(2))
				{
					ProcessSelection();
				}
			}
			return true;
		}

		public static void ProcessSelection()
		{
			Characters.CharacterSpecs stack = new Characters.CharacterSpecs();
			((MonoBehaviour)_self).StartCoroutine(preventClickCollection(2f));
			((MonoBehaviour)_self).StartCoroutine(Scripts.ProcessSequence(stack, (targetsCollection.targetsCollectingSpecType == "attack" || targetsCollection.targetsCollectingSpecType == "spell") ? Characters.CharactersSpecs.CheckType.Attack : Characters.CharactersSpecs.CheckType.Opposed, targetsCollection.targetsCollectingSpec, targetsCollection.targetsCollectingInstigator, targetsCollection.targetsCollected.ToArray(), targetsCollection.targetsCollectingPublicity));
			((MonoBehaviour)_self).StartCoroutine(holdAndClear(2f));
		}

		[IteratorStateMachine(typeof(<holdAndClear>d__3))]
		public static IEnumerator holdAndClear(float delay)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <holdAndClear>d__3(0)
			{
				delay = delay
			};
		}

		[IteratorStateMachine(typeof(<preventClickCollection>d__4))]
		public static IEnumerator preventClickCollection(float delay)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <preventClickCollection>d__4(0)
			{
				delay = delay
			};
		}
	}

	[HarmonyPatch(typeof(Ruler), "SetNewMode")]
	public static class PatchSetNewMode
	{
		public static bool Prefix(int newModeIndex, bool forceRecreate)
		{
			if (targetsCollection.targetsCollecting > 0)
			{
				LoggingPlugin.LogDebug("D20 Plugin: Ruler Mode Change To Type " + rulerTypes[newModeIndex] + " (" + newModeIndex + ")");
				collecting = rulerTypes[newModeIndex];
			}
			return true;
		}
	}

	[HarmonyPatch(typeof(Ruler), "OnClick")]
	public static class PatchOnClick
	{
		[CompilerGenerated]
		private sealed class <closeRuler>d__2 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <closeRuler>d__2(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Expected O, but got Unknown
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0069: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					UI_Rulers.EnableRulers(false);
					<>2__current = (object)new WaitForSeconds(0.1f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					UI_Rulers.EnableRulers(true);
					<>2__current = (object)new WaitForSeconds(0.1f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					UI_Rulers.EnableRulers(false);
					return false;
				}
			}

			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 static bool Prefix(Ruler __instance, int buttonId)
		{
			return true;
		}

		public static void Postfix(Ruler __instance, int buttonId)
		{
			//IL_030e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0315: Unknown result type (might be due to invalid IL or missing references)
			//IL_031a: Unknown result type (might be due to invalid IL or missing references)
			//IL_031f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0342: Unknown result type (might be due to invalid IL or missing references)
			//IL_0347: Unknown result type (might be due to invalid IL or missing references)
			//IL_0553: Unknown result type (might be due to invalid IL or missing references)
			//IL_0558: Unknown result type (might be due to invalid IL or missing references)
			//IL_0369: Unknown result type (might be due to invalid IL or missing references)
			//IL_036e: Unknown result type (might be due to invalid IL or missing references)
			//IL_038e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0395: Unknown result type (might be due to invalid IL or missing references)
			//IL_039a: Unknown result type (might be due to invalid IL or missing references)
			//IL_039f: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_040b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0410: Unknown result type (might be due to invalid IL or missing references)
			//IL_057a: Unknown result type (might be due to invalid IL or missing references)
			//IL_057f: Unknown result type (might be due to invalid IL or missing references)
			//IL_048c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0491: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_05cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0615: Unknown result type (might be due to invalid IL or missing references)
			//IL_061c: Unknown result type (might be due to invalid IL or missing references)
			//IL_062d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_0673: Unknown result type (might be due to invalid IL or missing references)
			//IL_0678: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			LoggingPlugin.LogDebug("Ruler " + ((Object)__instance).name + " Click: Button " + buttonId + ", Targets: " + targetsCollection.targetsCollecting + ", Collecting: " + PluginD20.collecting);
			if (PatchCallCameraClick.preventClickCalls || targetsCollection.targetsCollecting <= 0)
			{
				return;
			}
			List<Vector3> list = new List<Vector3>();
			if (!(PluginD20.collecting != ""))
			{
				return;
			}
			List<Vector3> list2 = new List<Vector3>();
			GameObject val = GameObject.Find(((Object)__instance).name);
			Vector3 val2;
			if ((Object)(object)val != (Object)null)
			{
				foreach (Transform item in ExtensionMethods.Children(val.transform))
				{
					LoggingPlugin.LogDebug("Ruler " + ((Object)__instance).name + ": Found Child: " + ((Object)item).name + " While Searching For " + PluginD20.collecting + "Indicator(Clone)");
					if (!(((Object)item).name == PluginD20.collecting + "Indicator(Clone)"))
					{
						continue;
					}
					LoggingPlugin.LogDebug("Ruler " + ((Object)__instance).name + ": Found " + ((Object)item).name + " With " + ExtensionMethods.Children(((Component)item).transform).Count() + " Children");
					foreach (Transform item2 in ExtensionMethods.Children(((Component)item).transform))
					{
						string collecting = PluginD20.collecting;
						val2 = item2.position;
						LoggingPlugin.LogDebug(collecting + " Point: " + ((object)(Vector3)(ref val2)).ToString());
						if (item2.position != Vector3.zero)
						{
							list.Add(item2.position);
						}
					}
				}
			}
			LoggingPlugin.LogDebug("Ruler " + ((Object)__instance).name + ": Collecting: " + PluginD20.collecting + ", Points: " + list.Count);
			string collecting2 = PluginD20.collecting;
			string text = collecting2;
			CreatureGuid creatureId;
			if (!(text == "Sphere"))
			{
				if (!(text == "Box") || list.Count != 2)
				{
					return;
				}
				LoggingPlugin.LogDebug("Ruler " + ((Object)__instance).name + ": Applying Selection Based On " + PluginD20.collecting);
				foreach (CreatureBoardAsset item3 in (IEnumerable<CreatureBoardAsset>)CreaturePresenter.GetTempReadOnlyViewOfAllCreatureAssets())
				{
					if (item3.CreatureId != LocalClient.SelectedCreatureId)
					{
						string[] obj = new string[8]
						{
							"Ruler ",
							((Object)__instance).name,
							": Asset ",
							item3.Name,
							" (",
							null,
							null,
							null
						};
						creatureId = item3.CreatureId;
						obj[5] = ((object)(CreatureGuid)(ref creatureId)).ToString();
						obj[6] = ") At ";
						val2 = ((Component)((MovableBoardAsset)item3).Rotator).transform.position;
						obj[7] = ((object)(Vector3)(ref val2)).ToString();
						LoggingPlugin.LogDebug(string.Concat(obj));
						if (IsPointInsideBox(list[0], list[1], ((Component)((MovableBoardAsset)item3).Rotator).transform.position))
						{
							string[] obj2 = new string[7]
							{
								"Ruler ",
								((Object)__instance).name,
								": Asset ",
								item3.Name,
								" (",
								null,
								null
							};
							creatureId = item3.CreatureId;
							obj2[5] = ((object)(CreatureGuid)(ref creatureId)).ToString();
							obj2[6] = ") Is Selected";
							LoggingPlugin.LogDebug(string.Concat(obj2));
							targetsCollection.targetsCollected.Add(item3);
						}
					}
				}
				PatchCallCameraClick.preventClickCalls = true;
				((MonoBehaviour)_self).StartCoroutine(PatchCallCameraClick.preventClickCollection(1f));
				((MonoBehaviour)_self).StartCoroutine(closeRuler());
				PluginD20.collecting = "";
			}
			else
			{
				if (list.Count != 2)
				{
					return;
				}
				LoggingPlugin.LogDebug("Ruler " + ((Object)__instance).name + ": Applying Selection Based On " + PluginD20.collecting);
				val2 = list[0] - list[1];
				float magnitude = ((Vector3)(ref val2)).magnitude;
				LoggingPlugin.LogDebug("Radius = " + magnitude);
				foreach (CreatureBoardAsset item4 in (IEnumerable<CreatureBoardAsset>)CreaturePresenter.GetTempReadOnlyViewOfAllCreatureAssets())
				{
					if (item4.CreatureId != LocalClient.SelectedCreatureId)
					{
						val2 = ((Component)((MovableBoardAsset)item4).Rotator).transform.position - list[0];
						float magnitude2 = ((Vector3)(ref val2)).magnitude;
						string[] obj3 = new string[11]
						{
							"Ruler ",
							((Object)__instance).name,
							": Asset ",
							item4.Name,
							" (",
							null,
							null,
							null,
							null,
							null,
							null
						};
						creatureId = item4.CreatureId;
						obj3[5] = ((object)(CreatureGuid)(ref creatureId)).ToString();
						obj3[6] = ") At ";
						val2 = ((Component)((MovableBoardAsset)item4).Rotator).transform.position;
						obj3[7] = ((object)(Vector3)(ref val2)).ToString();
						obj3[8] = " Is ";
						obj3[9] = magnitude2.ToString();
						obj3[10] = " away";
						LoggingPlugin.LogDebug(string.Concat(obj3));
						if (magnitude2 <= magnitude)
						{
							string[] obj4 = new string[7]
							{
								"Ruler ",
								((Object)__instance).name,
								": Asset ",
								item4.Name,
								" (",
								null,
								null
							};
							creatureId = item4.CreatureId;
							obj4[5] = ((object)(CreatureGuid)(ref creatureId)).ToString();
							obj4[6] = ") Is Selected";
							LoggingPlugin.LogDebug(string.Concat(obj4));
							targetsCollection.targetsCollected.Add(item4);
						}
					}
				}
				PatchCallCameraClick.preventClickCalls = true;
				((MonoBehaviour)_self).StartCoroutine(PatchCallCameraClick.preventClickCollection(1f));
				((MonoBehaviour)_self).StartCoroutine(closeRuler());
				PluginD20.collecting = "";
			}
		}

		[IteratorStateMachine(typeof(<closeRuler>d__2))]
		public static IEnumerator closeRuler()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <closeRuler>d__2(0);
		}

		public static bool IsPointInsideBox(Vector3 cornerA, Vector3 cornerB, Vector3 point)
		{
			//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_0013: 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_0025: 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_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: 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_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: 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_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: 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)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Min(cornerA.x, cornerB.x);
			float num2 = Mathf.Max(cornerA.x, cornerB.x);
			float num3 = Mathf.Min(cornerA.y, cornerB.y);
			float num4 = Mathf.Max(cornerA.y, cornerB.y);
			float num5 = Mathf.Min(cornerA.z, cornerB.z);
			float num6 = Mathf.Max(cornerA.z, cornerB.z);
			return point.x >= num && point.x <= num2 && point.y >= num3 && point.y <= num4 && point.z >= num5 && point.z <= num6;
		}
	}

	public class RemoteQuerySpecs
	{
		public string name { get; set; }

		public string item { get; set; }
	}

	public class RemoteQueryRequest
	{
		public Guid id { get; set; }

		public RemoteQuerySpecs query { get; set; }

		public string requestor { get; set; }

		public string[] targetClients { get; set; }

		public string[] targetPlayers { get; set; }
	}

	public class RemoteQueryResponse
	{
		public Guid id { get; set; }

		public string response { get; set; }

		public string requestor { get; set; }

		public string client { get; set; }

		public string player { get; set; }
	}

	public static class RemoteQuery
	{
		[CompilerGenerated]
		private sealed class <ProcessResultsAfterSetDelay>d__5 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Guid id;

			public TaskCompletionSource<List<RemoteQueryResponse>> token;

			public float delay;

			private List<RemoteQueryResponse> <returnResponse>5__1;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <ProcessResultsAfterSetDelay>d__5(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<returnResponse>5__1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					LoggingPlugin.LogDebug("Wait: Waiting For Responses: Started Wait For Timeout Of " + delay);
					<>2__current = (object)new WaitForSeconds(delay);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					LoggingPlugin.LogDebug("Wait: Triggering Set Delay Callback With " + results[id].Count + " results");
					<returnResponse>5__1 = results[id];
					results.Remove(id);
					LoggingPlugin.LogDebug("Wait: Results Removed From Queue. Posting Results (Token: " + ((token == null) ? "Null" : "Ready") + ")");
					token?.TrySetResult(<returnResponse>5__1);
					token = null;
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <ProcessResultsAfterSetResponses>d__6 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Guid id;

			public TaskCompletionSource<List<RemoteQueryResponse>> token;

			public int expectedResult;

			public int delay;

			private List<RemoteQueryResponse> <returnResponse>5__1;

			private ulong <i>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <ProcessResultsAfterSetResponses>d__6(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<returnResponse>5__1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00aa: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (delay == 0)
					{
						delay = int.MaxValue;
					}
					LoggingPlugin.LogDebug("Wait: Waiting For Responses: Started Wait For " + expectedResult + " Responses With Timeout Of " + delay);
					<i>5__2 = 0uL;
					break;
				case 1:
					<>1__state = -1;
					<i>5__2++;
					break;
				}
				if (<i>5__2 < (ulong)((long)delay * 2L) && results[id].Count < expectedResult)
				{
					<>2__current = (object)new WaitForSeconds(0.5f);
					<>1__state = 1;
					return true;
				}
				LoggingPlugin.LogDebug("Wait: Triggering Set Responses Callback With " + results[id].Count + " results");
				<returnResponse>5__1 = results[id];
				results.Remove(id);
				LoggingPlugin.LogDebug("Wait: Results Removed From Queue. Posting Results (Token: " + ((token == null) ? "Null" : "Ready") + ")");
				token?.TrySetResult(<returnResponse>5__1);
				token = null;
				return false;
			}

			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 static string hold;

		public static TaskCompletionSource<bool> reactionToken;

		public static Task<List<RemoteQueryResponse>> MakeRequest(RemoteQuerySpecs query, TaskCompletionSource<List<RemoteQueryResponse>> token, string[] specificClients = null, string[] specificPlayers = null, int expectedResult = 0, int expectedResultsTimeout = 0)
		{
			//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)
			Guid guid = System.Guid.NewGuid();
			results.Add(guid, new List<RemoteQueryResponse>());
			RemoteQueryRequest obj = new RemoteQueryRequest
			{
				id = guid,
				query = query
			};
			ClientGuid id = LocalClient.Id;
			obj.requestor = ((object)(ClientGuid)(ref id)).ToString();
			obj.targetClients = specificClients;
			obj.targetPlayers = specificPlayers;
			string text = JsonConvert.SerializeObject((object)obj);
			LoggingPlugin.LogDebug("Sending Remote Request:" + text);
			AssetDataPlugin.SendInfo("org.lordashes.plugins.d20", text);
			if (expectedResult == 0 && expectedResultsTimeout > 0)
			{
				((MonoBehaviour)_self).StartCoroutine(ProcessResultsAfterSetDelay(guid, token, expectedResultsTimeout));
			}
			else if (expectedResult == 0 && expectedResultsTimeout == 0)
			{
				((MonoBehaviour)_self).StartCoroutine(ProcessResultsAfterSetResponses(guid, token, expectedResult, 10));
			}
			else
			{
				((MonoBehaviour)_self).StartCoroutine(ProcessResultsAfterSetResponses(guid, token, expectedResult, expectedResultsTimeout));
			}
			return token.Task;
		}

		public static async void ReceiveRemoteQueryResult(DatumChange datum)
		{
			LoggingPlugin.LogDebug("Remote Message:" + JsonConvert.SerializeObject((object)datum));
			ChangeAction action2 = datum.action;
			ChangeAction val = action2;
			ChangeAction val2 = val;
			if ((int)val2 != 0 && val2 - 2 > 1)
			{
				return;
			}
			LoggingPlugin.LogDebug("Remote Message: Checking Message Type");
			ClientGuid id;
			if (datum.value.ToString().Contains("message:"))
			{
				SystemMessage.DisplayInfoText("D20 Plugin:\r\n" + datum.value.ToString().Substring("message:".Length), 2.5f, 0f, (Action)null);
			}
			else if (datum.value.ToString().Contains("action:"))
			{
				string action = datum.value.ToString().Substring("action:".Length);
				string text = action;
				if (text == "initiative")
				{
					LoggingPlugin.LogDebug("Remote Message: Starting Initiative Collection");
					collectingInitiative = true;
				}
			}
			else if (datum.value.ToString().Contains("query"))
			{
				LoggingPlugin.LogDebug("Remote Message: Is A Request");
				RemoteQueryRequest request = JsonConvert.DeserializeObject<RemoteQueryRequest>(datum.value.ToString());
				int num;
				if (request.targetClients != null)
				{
					string[] targetClients = request.targetClients;
					id = LocalClient.Id;
					num = ((!targetClients.Contains<string>(((object)(ClientGuid)(ref id)).ToString())) ? 1 : 0);
				}
				else
				{
					num = 0;
				}
				if (num != 0)
				{
					return;
				}
				PlayerGuid id2;
				int num2;
				if (request.targetPlayers != null)
				{
					string[] targetPlayers = request.targetPlayers;
					id2 = LocalPlayer.Id;
					num2 = ((!targetPlayers.Contains<string>(((object)(PlayerGuid)(ref id2)).ToString())) ? 1 : 0);
				}
				else
				{
					num2 = 0;
				}
				if (num2 != 0)
				{
					return;
				}
				LoggingPlugin.LogDebug("Remote Message: Seeking Sheets Matching " + request.query.name);
				Characters.CharacterSpecs[] queryResults = _self.characters.Find(DiceRoller.StripTrailingInteger(request.query.name));
				LoggingPlugin.LogDebug("Remote Message: Found " + ((queryResults == null) ? "0" : queryResults.Length.ToString()) + " Sheets");
				bool foundMatch = false;
				if (queryResults == null || queryResults.Length == 0)
				{
					return;
				}
				Characters.CharacterSpecs[] array = queryResults;
				foreach (Characters.CharacterSpecs sheet in array)
				{
					LoggingPlugin.LogDebug("Remote Message: Opposed Options " + request.query.item);
					string msg = "";
					string opposedOption = request.query.item;
					if (opposedOption.StartsWith("damage:"))
					{
						if (queryResults[0].FindFirstValue("Reaction") == "1")
						{
							LoggingPlugin.LogDebug("Delaying Response Until Opposing User Click Continue");
							hold = "Damage Reaction";
							await WaitForReaction();
						}
						LoggingPlugin.LogDebug("Remote Message: Looking For Damage Adjustments");
						string matchKeword = opposedOption.Substring("damage:".Length);
						LoggingPlugin.LogDebug("Remote Message: Looking For '" + matchKeword + "' Damage Adjustments");
						Characters.Spec immunitiesSpec = sheet.specs.Where((Characters.Spec e) => e.name == "Immunities").FirstOrDefault();
						Characters.Spec resistancesSpec = sheet.specs.Where((Characters.Spec e) => e.name == "Resistances").FirstOrDefault();
						Characters.Spec reductionsSpec = sheet.specs.Where((Characters.Spec e) => e.name == "Reductions").FirstOrDefault();
						Characters.Spec vulnerabilitiesSpec = sheet.specs.Where((Characters.Spec e) => e.name == "Vulnerabilities").FirstOrDefault();
						string immunities = ((immunitiesSpec != null) ? sheet.Resolve(immunitiesSpec.formula) : "");
						string resistances = ((resistancesSpec != null) ? sheet.Resolve(resistancesSpec.formula) : "");
						string reductions = ((reductionsSpec != null) ? sheet.Resolve(reductionsSpec.formula) : "");
						string vulnerabilities = ((vulnerabilitiesSpec != null) ? sheet.Resolve(vulnerabilitiesSpec.formula) : "");
						LoggingPlugin.LogDebug("Remote Message: Collected Possible Damage Adjustments");
						LoggingPlugin.LogDebug("Remote Message: Immunities = " + immunities);
						LoggingPlugin.LogDebug("Remote Message: Resistances = " + resistances);
						LoggingPlugin.LogDebug("Remote Message: Reductions = " + reductions);
						LoggingPlugin.LogDebug("Remote Message: Vulnerabilities = " + vulnerabilities);
						if (immunities != null && (immunities.Contains(matchKeword) || immunities.Contains("*")))
						{
							msg = msg + opposedOption + "=Immunity,";
						}
						else if (resistances != null && (resistances.Contains(matchKeword) || resistances.Contains("*")))
						{
							msg = msg + opposedOption + "=Resistance,";
						}
						else if (reductions == null || (!reductions.Contains(matchKeword) && !resistances.Contains("*")))
						{
							msg = ((vulnerabilities == null || (!vulnerabilities.Contains(matchKeword) && !vulnerabilities.Contains("*"))) ? (msg + opposedOption + "=Regular,") : (msg + opposedOption + "=Vulnerability,"));
						}
						else
						{
							string amount3 = reductions.Substring(reductions.IndexOf(matchKeword));
							amount3 = amount3.Substring(amount3.IndexOf("(") + 1);
							amount3 = amount3.Substring(0, amount3.IndexOf(")"));
							msg = msg + opposedOption + "=" + amount3 + ",";
						}
					}
					else
					{
						int bestScore = 0;
						string bestOptionName = "";
						Characters.Spec bestOption = null;
						string[] array2 = opposedOption.Split(new char[1] { ',' });
						foreach (string opposedOptionItem in array2)
						{
							if (queryResults[0].FindFirstValue("Reaction") == "1")
							{
								LoggingPlugin.LogDebug("Delaying Response Until Opposing User Click Continue");
								hold = "Defense Reaction";
								await WaitForReaction();
							}
							LoggingPlugin.LogDebug("Remote Message: Trying To Find " + opposedOption);
							Characters.Spec seekResult = sheet.specs.Where((Characters.Spec e) => e.name == opposedOption).FirstOrDefault();
							if (seekResult != null)
							{
								LoggingPlugin.LogDebug("Remote Message: Found " + seekResult.name + " (" + seekResult.formula + ")");
								int score = DiceRoller.ResolveMaxTotal(sheet.Resolve(seekResult.formula));
								if (score > bestScore)
								{
									bestScore = score;
									bestOptionName = opposedOptionItem;
									bestOption = seekResult;
								}
							}
						}
						CreatureBoardAsset target = null;
						try
						{
							target = ((IEnumerable<CreatureBoardAsset>)(object)CreaturePresenter.GetTempReadOnlyViewOfAllCreatureAssets()).Where((CreatureBoardAsset cba) => cba.Name == request.query.name).FirstOrDefault();
						}
						catch
						{
						}
						DiceRoller.RollResult rollResult = await DiceRoller.Roll(sheet, bestOptionName, bestOption.formula, rollingStyleDefensive);
						Scripts.ProcessExtensions(Scripts.ExtensionType.targetSkillResult, null, target, null, sheet, null, bestOptionName, null, rollResult, delegate(DiceRoller.RollResult r)
						{
							rollResult = r;
						});
						msg = msg + JsonConvert.SerializeObject((object)rollResult) + ",";
					}
					if (msg != "")
					{
						if (msg.IndexOf("=") < 0)
						{
							msg = "[" + msg.Substring(0, msg.Length - 1) + "]";
						}
						foundMatch = true;
						if (msg.EndsWith(","))
						{
							msg = msg.Substring(0, msg.Length - 1);
						}
						LoggingPlugin.LogDebug("Remote Message: Sending Result To Requestor " + request.requestor.ToString() + " Message '" + msg + "'");
						RemoteQueryResponse obj2 = new RemoteQueryResponse
						{
							id = request.id,
							requestor = request.requestor.ToString(),
							response = msg
						};
						id = LocalClient.Id;
						obj2.client = ((object)(ClientGuid)(ref id)).ToString();
						id2 = LocalPlayer.Id;
						obj2.player = ((object)(PlayerGuid)(ref id2)).ToString();
						RemoteQueryResponse response = obj2;
						AssetDataPlugin.SendInfo("org.lordashes.plugins.d20", JsonConvert.SerializeObject((object)response));
					}
				}
				if (!foundMatch)
				{
					SystemMessage.DisplayInfoText("Characte Sheet For " + request.query.name + " Is Missing " + request.query.item, 2.5f, 0f, (Action)null);
				}
			}
			else
			{
				LoggingPlugin.LogDebug("Remote Message: Is A Response");
				RemoteQueryResponse result = JsonConvert.DeserializeObject<RemoteQueryResponse>(datum.value.ToString());
				LoggingPlugin.LogDebug("Remote Message: Message Destined For Requestor " + result.requestor.ToString());
				string[] obj3 = new string[6] { "Remote Message: Check: ", result.requestor, "=", null, null, null };
				id = LocalClient.Id;
				obj3[3] = ((object)(ClientGuid)(ref id)).ToString();
				obj3[4] = ", Expecting Id=";
				obj3[5] = results.ContainsKey(result.id).ToString();
				LoggingPlugin.LogDebug(string.Concat(obj3));
				string requestor = result.requestor;
				id = LocalClient.Id;
				if (requestor == ((object)(ClientGuid)(ref id)).ToString() && results.ContainsKey(result.id))
				{
					LoggingPlugin.LogDebug("Remote Message: Adding Response To Results List (" + result.response + ")");
					results[result.id].Add(result);
					LoggingPlugin.LogDebug("Remote Message: Collected " + results[result.id].Count() + " Responses");
				}
			}
		}

		public static async Task WaitForReaction()
		{
			try
			{
				reactionToken = new TaskCompletionSource<bool>();
				await reactionToken.Task;
				LoggingPlugin.LogDebug("Reaction " + hold + " finished");
			}
			catch (OperationCanceledException)
			{
				LoggingPlugin.LogDebug("Reaction " + hold + " was canceled");
			}
			catch (Exception ex3)
			{
				Exception ex = ex3;
				Debug.LogException(ex);
			}
		}

		[IteratorStateMachine(typeof(<ProcessResultsAfterSetDelay>d__5))]
		public static IEnumerator ProcessResultsAfterSetDelay(Guid id, TaskCompletionSource<List<RemoteQueryResponse>> token, float delay)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ProcessResultsAfterSetDelay>d__5(0)
			{
				id = id,
				token = token,
				delay = delay
			};
		}

		[IteratorStateMachine(typeof(<ProcessResultsAfterSetResponses>d__6))]
		public static IEnumerator ProcessResultsAfterSetResponses(Guid id, TaskCompletionSource<List<RemoteQueryResponse>> token, int expectedResult, int delay)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ProcessResultsAfterSetResponses>d__6(0)
			{
				id = id,
				token = token,
				expectedResult = expectedResult,
				delay = delay
			};
		}
	}

	public static class Scripts
	{
		public class Script
		{
			public string use { get; set; }

			public string gm { get; set; }

			public string instigator { get; set; }

			public string target { get; set; }

			public string others { get; set; }

			public string instigator_speech { get; set; }

			public string target_speech { get; set; }
		}

		public enum ExtensionType
		{
			instigatorSkillResult = 1,
			targetSkillResult,
			damageResult
		}

		public class ToggleCallaback
		{
			public ToggleRequired toggleOnWho { get; set; }

			public string toggleName { get; set; }

			public Func<CreatureBoardAsset, CreatureBoardAsset, Characters.CharacterSpecs, Characters.CharacterSpecs, Characters.Spec, string, Characters.Spec, DiceRoller.RollResult, Task<DiceRoller.RollResult>> callback { get; set; }
		}

		public enum ToggleRequired
		{
			instigator,
			target
		}

		public enum MessagePublicity
		{
			publicMessage,
			semiPrivateMessage,
			privateMessage
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass11_0
		{
			public Task<DiceRoller.RollResult> extensionTask;

			internal bool <ProcessExtensions>b__0()
			{
				return extensionTask.IsCompleted;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass12_0
		{
			public Task<List<RemoteQueryResponse>> queryTask;

			internal bool <QueryRemotes>b__0()
			{
				return queryTask.IsCompleted;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass13_0
		{
			public Task<List<RemoteQueryResponse>> queryTask;

			internal bool <QueryRemotesForDamage>b__0()
			{
				return queryTask.IsCompleted;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass14_0
		{
			public Task<DiceRoller.RollResult> rollTask;

			internal bool <RollDice>b__0()
			{
				return rollTask.IsCompleted;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass16_0
		{
			public DiceRoller.RollResult rollResult;

			internal void <ProcessInstigatorRoll>b__0(DiceRoller.RollResult r)
			{
				rollResult = r;
			}

			internal void <ProcessInstigatorRoll>b__1(DiceRoller.RollResult r)
			{
				rollResult = r;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass17_0
		{
			public DiceRoller.RollResult opposedRoll;

			internal void <ProcessTargetRoll>b__0(DiceRoller.RollResult r)
			{
				opposedRoll = r;
			}

			internal void <ProcessTargetRoll>b__1(DiceRoller.RollResult r)
			{
				opposedRoll = r;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass18_0
		{
			public string adjustor;

			public DiceRoller.RollResult damage;

			internal void <ProcessDamageOnTarget>b__0(string r)
			{
				adjustor = r;
			}

			internal void <ProcessDamageOnTarget>b__1(DiceRoller.RollResult r)
			{
				damage = r;
			}

			internal void <ProcessDamageOnTarget>b__2(DiceRoller.RollResult r)
			{
				damage = r;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass20_0
		{
			public DiceRoller.RollResult heal;

			internal void <ProcessHealOnTarget>b__0(DiceRoller.RollResult r)
			{
				heal = r;
			}
		}

		[CompilerGenerated]
		private sealed class <AnimateAttack>d__22 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Characters.Spec check;

			public CreatureBoardAsset instigator;

			public CreatureBoardAsset target;

			public bool firstTarget;

			public bool success;

			private float <distance>5__1;

			private string <anim>5__2;

			private AttackEmotes <animEmote>5__3;

			private Transform <hook>5__4;

			private Projectile <projectile>5__5;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <AnimateAttack>d__22(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<anim>5__2 = null;
				<hook>5__4 = null;
				<projectile>5__5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0046: 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_01bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_0262: Unknown result type (might be due to invalid IL or missing references)
				//IL_0366: Unknown result type (might be due to invalid IL or missing references)
				//IL_036b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0375: Expected O, but got Unknown
				//IL_0383: Unknown result type (might be due to invalid IL or missing references)
				//IL_0388: Unknown result type (might be due to invalid IL or missing references)
				//IL_0392: Expected O, but got Unknown
				//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
				//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_02dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_02e2: Unknown result type (might be due to invalid IL or missing references)
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				LoggingPlugin.LogDebug("Starting AnimateAttack...");
				if (useAnimations.Value)
				{
					<distance>5__1 = (int)Math.Floor(Vector3.Distance(((Component)((MovableBoardAsset)instigator).Rotator).transform.position, ((Component)((MovableBoardAsset)target).Rotator).transform.position) * 5f);
					if (!success)
					{
						LoggingPlugin.LogDebug("Miss: Doing Wiggle Animation");
						target.PlayEmote(missAnimation.Value.ToString());
					}
					else
					{
						<anim>5__2 = check.Extra("animOnce");
						LoggingPlugin.LogDebug("Target " + (firstTarget ? "is" : "is not") + " first target. AnimOnce is " + ((<anim>5__2 == null) ? "Null" : <anim>5__2));
						if (<anim>5__2 != null && !firstTarget)
						{
							LoggingPlugin.LogDebug("AnimOnce set but this not the first target. Supressing animation.");
							<anim>5__2 = "";
						}
						if (<anim>5__2 == null)
						{
							LoggingPlugin.LogDebug("AnimOnce not set. Checking Anim.");
							<anim>5__2 = check.Extra("anim");
						}
						if (<anim>5__2 == null)
						{
							LoggingPlugin.LogDebug("Anim not set. Using defaut.");
							AttackEmotes value;
							string? text;
							if (!(<distance>5__1 < 10f))
							{
								value = hitRangedAnimation.Value;
								text = ((object)(AttackEmotes)(ref value)).ToString();
							}
							else
							{
								value = hitMeleeAnimation.Value;
								text = ((object)(AttackEmotes)(ref value)).ToString();
							}
							<anim>5__2 = text;
						}
						if (<anim>5__2 != null && <anim>5__2 != "")
						{
							LoggingPlugin.LogDebug(instigator.Name + " and " + target.Name + " Are " + <distance>5__1 + "' Apart. Doing A " + <anim>5__2 + " Animation");
							<animEmote>5__3 = (AttackEmotes)0;
							if (Enum.TryParse<AttackEmotes>(<anim>5__2, out <animEmote>5__3))
							{
								LoggingPlugin.LogDebug("Using Core Animation " + <anim>5__2);
								<hook>5__4 = ((EmotingMovableBoardAsset)target).GetHook((HookTransform)2) ?? ((Component)((MovableBoardAsset)target).Rotator).transform;
								CreaturePresenter.OnCreatureAttack(<animEmote>5__3, instigator.CreatureId, target.CreatureId, float3.op_Implicit(<hook>5__4.position));
								<hook>5__4 = null;
							}
							else
							{
								LoggingPlugin.LogDebug("Using Projectile Animation " + <anim>5__2);
								if (projectiles.ContainsKey(<anim>5__2))
								{
									<projectile>5__5 = projectiles[<anim>5__2];
									<projectile>5__5.targets = 1;
									<projectile>5__5.sources = new List<P3>
									{
										new P3(((EmotingMovableBoardAsset)instigator).GetHook((HookTransform)1).position),
										new P3(((EmotingMovableBoardAsset)target).GetHook((HookTransform)2).position)
									};
									<projectile>5__5.targetArea = "HIT";
									AssetDataPlugin.SendInfo("org.lordashes.plugins.projectile", JsonConvert.SerializeObject((object)<projectile>5__5));
									<projectile>5__5 = null;
								}
								else
								{
									LoggingPlugin.LogDebug(check.name + " Using Projectile Animation " + <anim>5__2 + " But It Is Not Defined.");
								}
							}
						}
						<anim>5__2 = null;
					}
				}
				LoggingPlugin.LogDebug("Ended AnimateAttack...");
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <DelayedCreatureRemove>d__23 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public CreatureGuid cid;

			public float removeDeadMinisAfterSeconds;

			private List<EmoteCollectionItem>.Enumerator <>s__1;

			private EmoteCollectionItem <emote>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <DelayedCreatureRemove>d__23(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>s__1 = default(List<EmoteCollectionItem>.Enumerator);
				<emote>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_008b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0095: Expected O, but got Unknown
				//IL_014a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0151: Unknown result type (might be due to invalid IL or missing references)
				//IL_0157: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00db: Unknown result type (might be due to invalid IL or missing references)
				//IL_011d: Unknown result type (might be due to invalid IL or missing references)
				//IL_012f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0139: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					LoggingPlugin.LogDebug("Starting DelayedCreatureRemove...");
					LoggingPlugin.LogDebug("Removing Creature " + ((object)(CreatureGuid)(ref cid)).ToString() + " After " + removeDeadMinisAfterSeconds + " Seconds");
					<>2__current = (object)new WaitForSeconds(removeDeadMinisAfterSeconds);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>s__1 = EmoteManager.GetCollection().Emotes.GetEnumerator();
					try
					{
						while (<>s__1.MoveNext())
						{
							<emote>5__2 = <>s__1.Current;
							CreatureManager.RemovePersistentEmote(cid, <emote>5__2.Id);
							<emote>5__2 = null;
						}
					}
					finally
					{
						((IDisposable)<>s__1).Dispose();
					}
					<>s__1 = default(List<EmoteCollectionItem>.Enumerator);
					CreatureManager.SetCreatureExplicitHideState(cid, true);
					<>2__current = (object)new WaitForSeconds(1f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					CreatureManager.DeleteCreature(cid, default(UniqueCreatureGuid), false);
					LoggingPlugin.LogDebug("Ended DelayedCreatureRemove...");
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <ProcessDamageOnTarget>d__18 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Characters.CharacterSpecs stack;

			public Characters.CharactersSpecs.CheckType action;

			public Characters.Spec check;

			public CreatureBoardAsset instigator;

			public CreatureBoardAsset target;

			public string severity;

			public MessagePublicity publicity;

			public string overrideDamage;

			private Characters.CharacterSpecs <instigatorSheet>5__1;

			private Characters.CharacterSpecs <targetSheet>5__2;

			private string[] <damageSpecNames>5__3;

			private string <dmg>5__4;

			private string[] <>s__5;

			private int <>s__6;

			private string <damageSpecNameRaw>5__7;

			private string <damageSpecName>5__8;

			private <>c__DisplayClass18_0 <>8__9;

			private Characters.Spec <damageSpec>5__10;

			private string <critString>5__11;

			private bool <crit>5__12;

			private string <critFormula>5__13;

			private string <cf>5__14;

			private string <damageFormula>5__15;

			private int <damageAdjusted>5__16;

			private int <adjustorInt>5__17;

			private string <dt>5__18;

			private CreatureDataV4 <creatureData>5__19;

			private float <lifePercentage>5__20;

			private string <>s__21;

			private EmoteCollectionItem <emote>5__22;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <ProcessDamageOnTarget>d__18(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				<instigatorSheet>5__1 = null;
				<targetSheet>5__2 = null;
				<damageSpecNames>5__3 = null;
				<dmg>5__4 = null;
				<>s__5 = null;
				<damageSpecNameRaw>5__7 = null;
				<damageSpecName>5__8 = null;
				<>8__9 = null;
				<damageSpec>5__10 = null;
				<critString>5__11 = null;
				<critFormula>5__13 = null;
				<cf>5__14 = null;
				<damageFormula>5__15 = null;
				<dt>5__18 = null;
				<creatureData>5__19 = default(CreatureDataV4);
				<>s__21 = null;
				<emote>5__22 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0e50: Unknown result type (might be due to invalid IL or missing references)
				//IL_0e5a: Expected O, but got Unknown
				//IL_0adc: Unknown result type (might be due to invalid IL or missing references)
				//IL_0b82: Unknown result type (might be due to invalid IL or missing references)
				//IL_0dd3: Unknown result type (might be due to invalid IL or missing references)
				//IL_0dde: Unknown result type (might be due to invalid IL or missing references)
				//IL_0df6: Unknown result type (might be due to invalid IL or missing references)
				//IL_0e00: Unknown result type (might be due to invalid IL or missing references)
				//IL_0e44: Unknown result type (might be due to invalid IL or missing references)
				//IL_0d93: Unknown result type (might be due to invalid IL or missing references)
				//IL_0d24: Unknown result type (might be due to invalid IL or missing references)
				//IL_0d2f: Unknown result type (might be due to invalid IL or missing references)
				string adjustor;
				string[] obj;
				Characters.CharacterSpecs characterSpecs;
				Characters.CharacterSpecs characterSpecs2;
				float value;
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					LoggingPlugin.LogDebug("Starting ProcessDamageOnTarget..." + instigator.Name + " To " + (((Object)(object)target != (Object)null) ? target.Name : "None"));
					stack.AddOrModifyValue("instigatorName", ((Object)(object)instigator != (Object)null) ? instigator.Name : "None");
					stack.AddOrModifyValue("targetName", ((Object)(object)target != (Object)null) ? target.Name : "None");
					<instigatorSheet>5__1 = _self.characters.FindFirst(DiceRoller.StripTrailingInteger(instigator.Name));
					<targetSheet>5__2 = _self.characters.FindFirst(DiceRoller.StripTrailingInteger(target.Name));
					<dmg>5__4 = check.Extra("damage");
					<damageSpecNames>5__3 = ((<dmg>5__4 != null) ? <dmg>5__4.Replace("[", "").Replace("]", "").Replace("'", "")
						.Split(new char[1] { ',' }) : new string[0]);
					if (overrideDamage != null)
					{
						<damageSpecNames>5__3 = overrideDamage.Split(new char[1] { ',' });
					}
					LoggingPlugin.LogDebug("Damages: " + string.Join(",", <damageSpecNames>5__3));
					<>s__5 = <damageSpecNames>5__3;
					<>s__6 = 0;
					goto IL_0e87;
				case 1:
					<>1__state = -1;
					waitingOnRemoteAction = false;
					<>8__9.adjustor = <>8__9.adjustor.Substring(<>8__9.adjustor.IndexOf("=") + 1);
					<critString>5__11 = stack.FindFirstValue("crit");
					<crit>5__12 = ((<critString>5__11 != null && <critString>5__11 != "" && bool.Parse(<critString>5__11)) ? true : false);
					<cf>5__14 = <damageSpec>5__10.Extra("critFormula");
					<critFormula>5__13 = ((<cf>5__14 != null) ? <cf>5__14 : <damageSpec>5__10.formula);
					<damageFormula>5__15 = "";
					if (<crit>5__12)
					{
						LoggingPlugin.LogDebug("Using Crit Damage: \"" + Convert.ToString(<critFormula>5__13) + "\"");
						<damageFormula>5__15 = <critFormula>5__13;
					}
					else
					{
						LoggingPlugin.LogDebug("Using Regular Damage: \"" + Convert.ToString(<damageSpec>5__10.formula) + "\"");
						<damageFormula>5__15 = <damageSpec>5__10.formula;
					}
					<>8__9.damage = null;
					if (commonDamage == null)
					{
						<>2__current = RollDice(<instigatorSheet>5__1, <damageSpec>5__10.name, <damageFormula>5__15, delegate(DiceRoller.RollResult r)
						{
							<>8__9.damage = r;
						});
						<>1__state = 2;
						return true;
					}
					<>8__9.damage = commonDamage;
					goto IL_06b1;
				case 2:
					<>1__state = -1;
					stack.AddOrModifyValue("damageName", <damageSpec>5__10.name);
					stack.AddOrModifyValue("damageType", <instigatorSheet>5__1.Resolve(<damageSpec>5__10.Extra("damageType")));
					stack.AddOrModifyValue("damageFormula", <>8__9.damage.formula);
					stack.AddOrModifyValue("damageRoll", <>8__9.damage.formulaResolved);
					stack.AddOrModifyValue("damageDice", <>8__9.damage.formulaDice);
					stack.AddOrModifyValue("damageTotal", <>8__9.damage.total.ToString());
					<>2__current = ProcessExtensions(ExtensionType.damageResult, instigator, target, <instigatorSheet>5__1, <targetSheet>5__2, check, null, <damageSpec>5__10, <>8__9.damage, delegate(DiceRoller.RollResult r)
					{
						<>8__9.damage = r;
					});
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					if (!ResolvePlaceHolders(<instigatorSheet>5__1, check.formula).Contains("1D20"))
					{
						LoggingPlugin.LogDebug("Storing Common Damage");
						commonDamage = <>8__9.damage;
					}
					else
					{
						LoggingPlugin.LogDebug("Using Individual Damage");
					}
					goto IL_06b1;
				case 4:
					{
						<>1__state = -1;
						<damageSpecName>5__8 = null;
						<damageSpecNameRaw>5__7 = null;
						<>s__6++;
						goto IL_0e87;
					}
					IL_0e4a:
					<>2__current = (object)new WaitForSeconds(0.01f);
					<>1__state = 4;
					return true;
					IL_06b1:
					stack.AddOrModifyValue("damageName", <damageSpec>5__10.name);
					stack.AddOrModifyValue("damageType", <instigatorSheet>5__1.Resolve(<damageSpec>5__10.Extra("damageType")));
					stack.AddOrModifyValue("damageFormula", <>8__9.damage.formula);
					stack.AddOrModifyValue("damageRoll", <>8__9.damage.formulaResolved);
					stack.AddOrModifyValue("damageDice", <>8__9.damage.formulaDice);
					stack.AddOrModifyValue("damageTotal", <>8__9.damage.total.ToString());
					<damageAdjusted>5__16 = <>8__9.damage.total;
					if (<damageSpec>5__10.Extra("damageType").ToUpper() == "NON-RESISTED")
					{
						<>8__9.adjustor = "Regular";
					}
					LoggingPlugin.LogDebug("Damage Total: " + <damageAdjusted>5__16);
					if (severity.ToUpper() == "HIT")
					{
						<damageAdjusted>5__16 = <>8__9.damage.total;
					}
					else
					{
						<damageAdjusted>5__16 = Convert.ToInt32(<>8__9.damage.total / 2);
					}
					LoggingPlugin.LogDebug("Damage Total After Save-For-Half Adjustment: " + <damageAdjusted>5__16);
					adjustor = <>8__9.adjustor;
					<>s__21 = adjustor;
					switch (<>s__21)
					{
					case "Vulnerability":
						LoggingPlugin.LogDebug("Applying Vulnerability");
						<damageAdjusted>5__16 *= 2;
						break;
					case "Resistance":
						LoggingPlugin.LogDebug("Applying Resistance");
						<damageAdjusted>5__16 = Convert.ToInt32(<damageAdjusted>5__16 / 2);
						break;
					case "Immunity":
						LoggingPlugin.LogDebug("Applying Immunity");
						<damageAdjusted>5__16 = 0;
						break;
					}
					<>s__21 = null;
					LoggingPlugin.LogDebug("Damage Total After V/R/I Adjustment: " + <damageAdjusted>5__16);
					<adjustorInt>5__17 = 0;
					if (int.TryParse(<>8__9.adjustor, out <adjustorInt>5__17))
					{
						LoggingPlugin.LogDebug("Applying Reduction " + <>8__9.adjustor);
						<damageAdjusted>5__16 -= <adjustorInt>5__17;
						<>8__9.adjustor = "Reduction(" + <>8__9.adjustor + ")";
					}
					<damageAdjusted>5__16 = Math.Max(<damageAdjusted>5__16, 0);
					obj = new string[8]
					{
						instigator.Name,
						"'s ",
						check.name,
						" does ",
						<damageAdjusted>5__16.ToString(),
						" ",
						null,
						null
					};
					<dt>5__18 = <damageSpec>5__10.Extra("damageType");
					obj[6] = ((<dt>5__18 != null) ? <dt>5__18 : "Generic");
					obj[7] = " damage";
					LoggingPlugin.LogInfo(string.Concat(obj));
					stack.AddOrModifyValue("damageAdjusted", <damageAdjusted>5__16.ToString());
					if (severity == "Half")
					{
						if (<>8__9.adjustor == "Regular")
						{
							<>8__9.adjustor = "Save";
						}
						else
						{
							<>8__9.adjustor = "Save With " + <>8__9.adjustor;
						}
					}
					stack.AddOrModifyValue("damageAdjustor", <>8__9.adjustor);
					CreatureManager.TryGetCreatureData(target.CreatureId, ref <creatureData>5__19);
					characterSpecs = stack;
					value = <creatureData>5__19.Hp.Value;
					characterSpecs.AddOrModifyValue("targetOldHP", value.ToString());
					stack.AddOrModifyValue("targetHP", (<creatureData>5__19.Hp.Value - (float)<damageAdjusted>5__16).ToString());
					characterSpecs2 = stack;
					value = <creatureData>5__19.Hp.Max;
					characterSpecs2.AddOrModifyValue("targetMaxHP", value.ToString());
					<lifePercentage>5__20 = 100f * (target.Hp.Value - (float)<damageAdjusted>5__16) / <creatureData>5__19.Hp.Max;
					if (<lifePercentage>5__20 == 100f)
					{
						stack.AddOrModifyValue("targetState", "Unhurt");
					}
					else if (<lifePercentage>5__20 >= 75f)
					{
						stack.AddOrModifyValue("targetState", "Scratched");
					}
					else if (<lifePercentage>5__20 >= 50f)
					{
						stack.AddOrModifyValue("targetState", "Wounded");
					}
					else if (<lifePercentage>5__20 >= 25f)
					{
						stack.AddOrModifyValue("targetState", "Bloodied");
					}
					else if (<lifePercentage>5__20 > 0f)
					{
						stack.AddOrModifyValue("targetState", "Critical");
					}
					else
					{
						stack.AddOrModifyValue("targetState", "Dying");
						if (useAnimations.Value)
						{
							<emote>5__22 = EmoteManager.GetCollection().Emotes.Where((EmoteCollectionItem e) => ((Object)e.Emote).name.Contains(deadAnimation.Value.ToString()) || e.Emote.DisplayName.Contains(deadAnimation.Value.ToString())).FirstOrDefault();
							if (<emote>5__22 != null)
							{
								CreatureManager.AddPersistentEmote(target.CreatureId, <emote>5__22.Id);
							}
							else
							{
								LoggingPlugin.LogDebug("Unable to find the `" + deadAnimation.Value.ToString() + "` emote");
							}
							<emote>5__22 = null;
						}
						if (removeDeadMinisAfterSeconds > 0f)
						{
							((MonoBehaviour)_self).StartCoroutine(DelayedCreatureRemove(target.CreatureId, removeDeadMinisAfterSeconds));
						}
					}
					SendMessages("Damage", stack, instigator, target, publicity);
					CreatureManager.SetCreatureStatByIndex(target.CreatureId, new CreatureStat(target.Hp.Value - (float)<damageAdjusted>5__16, target.Hp.Max), -1);
					<>8__9 = null;
					<damageSpec>5__10 = null;
					<critString>5__11 = null;
					<critFormula>5__13 = null;
					<cf>5__14 = null;
					<damageFormula>5__15 = null;
					<dt>5__18 = null;
					<creatureData>5__19 = default(CreatureDataV4);
					goto IL_0e4a;
					IL_0e87:
					if (<>s__6 < <>s__5.Length)
					{
						<damageSpecNameRaw>5__7 = <>s__5[<>s__6];
						<damageSpecName>5__8 = <damageSpecNameRaw>5__7.Trim();
						if (<damageSpecName>5__8.Trim() != "" || <damageSpecName>5__8.ToUpper() != "NONE")
						{
							<>8__9 = new <>c__DisplayClass18_0();
							LoggingPlugin.LogDebug("Damage: '" + <damageSpecName>5__8 + "'");
							<damageSpec>5__10 = <instigatorSheet>5__1.FindFirst(<damageSpecName>5__8);
							LoggingPlugin.LogDebug("Found damage spec '" + <damageSpecName>5__8 + "': " + (<damageSpec>5__10 != null));
							LoggingPlugin.LogDebug("Querying " + target.Name + " For Modifiers To " + <damageSpec>5__10.Extra("damageType"));
							<>8__9.adjustor = null;
							waitingOnRemoteAction = true;
							<>2__current = QueryRemotesForDamage(new RemoteQuerySpecs
							{
								name = target.Name,
								item = "damage:" + <damageSpec>5__10.Extra("damageType")
							}, new TaskCompletionSource<List<RemoteQueryResponse>>(), null, null, 1, 0, delegate(string r)
							{
								<>8__9.adjustor = r;
							});
							<>1__state = 1;
							return true;
						}
						goto IL_0e4a;
					}
					<>s__5 = null;
					LoggingPlugin.LogDebug("Ended ProcessDamageOnTarget...");
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <ProcessEffectOnTarget>d__19 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Characters.CharacterSpecs stack;

			public Characters.CharactersSpecs.CheckType action;

			public Characters.Spec check;

			public CreatureBoardAsset instigator;

			public CreatureBoardAsset target;

			public string severity;

			public MessagePublicity publicity;

			public string overrideEffect;

			private Characters.CharacterSpecs <instigatorSheet>5__1;

			private string[] <effectSpecNames>5__2;

			private string <dmg>5__3;

			private string[] <>s__4;

			private int <>s__5;

			private string <effectSpecNameRaw>5__6;

			private string <effectSpecName>5__7;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <ProcessEffectOnTarget>d__19(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<instigatorSheet>5__1 = null;
				<effectSpecNames>5__2 = null;
				<dmg>5__3 = null;
				<>s__4 = null;
				<effectSpecNameRaw>5__6 = null;
				<effectSpecName>5__7 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0322: Unknown result type (might be due to invalid IL or missing references)
				//IL_032c: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					LoggingPlugin.LogDebug("Starting ProcessEffectOnTarget..." + instigator.Name + " To " + (((Object)(object)target != (Object)null) ? target.Name : "None"));
					stack.AddOrModifyValue("instigatorName", instigator.Name);
					stack.AddOrModifyValue("targetName", target.Name);
					<instigatorSheet>5__1 = _self.characters.FindFirst(DiceRoller.StripTrailingInteger(instigator.Name));
					<dmg>5__3 = check.Extra("effect");
					<effectSpecNames>5__2 = ((<dmg>5__3 != null) ? <dmg>5__3.Replace("[", "").Replace("]", "").Replace("'", "")
						.Split(new char[1] { ',' }) : new string[0]);
					if (overrideEffect != null)
					{
						<effectSpecNames>5__2 = overrideEffect.Split(new char[1] { ',' });
					}
					LoggingPlugin.LogDebug("Effects: " + string.Join(", ", <effectSpecNames>5__2));
					<>s__4 = <effectSpecNames>5__2;
					<>s__5 = 0;
					break;
				case 1:
					<>1__state = -1;
					<effectSpecName>5__7 = null;
					<effectSpecNameRaw>5__6 = null;
					<>s__5++;
					break;
				}
				if (<>s__5 < <>s__4.Length)
				{
					<effectSpecNameRaw>5__6 = <>s__4[<>s__5];
					<effectSpecName>5__7 = <effectSpecNameRaw>5__6.Trim();
					if (<effectSpecName>5__7.Trim() != "" || <effectSpecName>5__7.ToUpper() != "NONE")
					{
						LoggingPlugin.LogDebug("Effect: '" + <effectSpecName>5__7 + "'");
						stack.AddOrModifyValue("effect", <instigatorSheet>5__1.FindFirstValue(<effectSpecName>5__7));
						if (severity == "Hit")
						{
							LoggingPlugin.LogInfo(instigator.Name + " inflicts " + <effectSpecName>5__7 + " hit effect on " + target.Name);
							SendMessages("Effect.Hit", stack, instigator, target, publicity);
						}
						else
						{
							LoggingPlugin.LogInfo(instigator.Name + " inflicts " + <effectSpecName>5__7 + " miss effect on " + target.Name);
							SendMessages("Effect.Miss", stack, instigator, target, publicity);
						}
					}
					<>2__current = (object)new WaitForSeconds(0.01f);
					<>1__state = 1;
					return true;
				}
				<>s__4 = null;
				LoggingPlugin.LogDebug("Ended ProcessEffectOnTarget...");
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <ProcessExtensions>d__11 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public ExtensionType extensionType;

			public CreatureBoardAsset instigator;

			public CreatureBoardAsset target;

			public Characters.CharacterSpecs instigatorSheet;

			public Characters.CharacterSpecs targetSheet;

			public Characters.Spec instigatorCheck;

			public string targetCheck;

			public Characters.Spec spec;

			public DiceRoller.RollResult rollResult;

			public Action<DiceRoller.RollResult> onComplete;

			private List<ToggleCallaback>.Enumerator <>s__1;

			private ToggleCallaback <extension>5__2;

			private <>c__DisplayClass11_0 <>8__3;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <ProcessExtensions>d__11(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>s__1 = default(List<ToggleCallaback>.Enumerator);
				<extension>5__2 = null;
				<>8__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0151: Unknown result type (might be due to invalid IL or missing references)
				//IL_015b: Expected O, but got Unknown
				try
				{
					int num = <>1__state;
					if (num != 0)
					{
						if (num != 1)
						{
							return false;
						}
						<>1__state = -3;
						rollResult = <>8__3.extensionTask.Result;
						<>8__3 = null;
						goto IL_018c;
					}
					<>1__state = -1;
					<>s__1 = extensions[extensionType].GetEnumerator();
					<>1__state = -3;
					goto IL_0194;
					IL_018c:
					<extension>5__2 = null;
					goto IL_0194;
					IL_0194:
					if (<>s__1.MoveNext())
					{
						<extension>5__2 = <>s__1.Current;
						if ((<extension>5__2.toggleOnWho == ToggleRequired.instigator && instigatorSheet.FindFirstValue(<extension>5__2.toggleName) == "1") || (<extension>5__2.toggleOnWho == ToggleRequired.target && targetSheet.FindFirstValue(<extension>5__2.toggleName) == "1"))
						{
							<>8__3 = new <>c__DisplayClass11_0();
							LoggingPlugin.LogDebug("Executing Extension For " + <extension>5__2.toggleName);
							<>8__3.extensionTask = <extension>5__2.callback(instigator, target, instigatorSheet, targetSheet, instigatorCheck, targetCheck, spec, rollResult);
							<>2__current = (object)new WaitUntil((Func<bool>)(() => <>8__3.extensionTask.IsCompleted));
							<>1__state = 1;
							return true;
						}
						goto IL_018c;
					}
					<>m__Finally1();
					<>s__1 = default(List<ToggleCallaback>.Enumerator);
					onComplete?.Invoke(rollResult);
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				((IDisposable)<>s__1).Dispose();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <ProcessGeneric>d__21 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Characters.CharacterSpecs stack;

			public Characters.CharactersSpecs.CheckType action;

			public Characters.Spec check;

			public CreatureBoardAsset instigator;

			public CreatureBoardAsset target;

			public MessagePublicity publicity;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <ProcessGeneric>d__21(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					LoggingPlugin.LogDebug("Starting ProcessGeneric...");
					<>2__current = (object)new WaitForSeconds(0.1f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					stack.AddOrModifyValue("instigatorName", instigator.Name);
					stack.AddOrModifyValue("targetName", target.Name);
					stack.AddOrModifyValue("name", check.name);
					SendMessages("Generic", stack, instigator, target, publicity);
					LoggingPlugin.LogDebug("Ended ProcessGeneric...");
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <ProcessHealOnTarget>d__20 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Characters.CharacterSpecs stack;

			public Characters.CharactersSpecs.CheckType action;

			public Characters.Spec check;

			public CreatureBoardAsset instigator;

			public CreatureBoardAsset target;

			public MessagePublicity publicity;

			private <>c__DisplayClass20_0 <>8__1;

			private Characters.CharacterSpecs <instigatorSheet>5__2;

			private CreatureDataV4 <creatureData>5__3;

			private float <lifePercentage>5__4;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <ProcessHealOnTarget>d__20(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				<>8__1 = null;
				<instigatorSheet>5__2 = null;
				<creatureData>5__3 = default(CreatureDataV4);
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_046b: Unknown result type (might be due to invalid IL or missing references)
				//IL_04b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_04c1: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass20_0();
					LoggingPlugin.LogDebug("Starting ProcessHealOnTarget..." + instigator.Name + " To " + (((Object)(object)target != (Object)null) ? target.Name : "None"));
					stack.AddOrModifyValue("instigatorName", instigator.Name);
					stack.AddOrModifyValue("targetName", target.Name);
					<instigatorSheet>5__2 = _self.characters.FindFirst(DiceRoller.StripTrailingInteger(instigator.Name));
					<>8__1.heal = null;
					<>2__current = RollDice(<instigatorSheet>5__2, check.name, check.formula, delegate(DiceRoller.RollResult r)
					{
						<>8__1.heal = r;
					});
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					stack.AddOrModifyValue("healName", check.name);
					stack.AddOrModifyValue("healFormula", <>8__1.heal.formula);
					stack.AddOrModifyValue("healRoll", <>8__1.heal.formulaResolved);
					stack.AddOrModifyValue("healDice", <>8__1.heal.formulaDice);
					stack.AddOrModifyValue("healTotal", <>8__1.heal.total.ToString());
					CreatureManager.TryGetCreatureData(target.CreatureId, ref <creatureData>5__3);
					Characters.CharacterSpecs characterSpecs = stack;
					float value = <creatureData>5__3.Hp.Value;
					characterSpecs.AddOrModifyValue("targetOldHP", value.ToString());
					stack.AddOrModifyValue("targetHP", (<creatureData>5__3.Hp.Value + (float)<>8__1.heal.total).ToString());
					Characters.CharacterSpecs characterSpecs2 = stack;
					value = <creatureData>5__3.Hp.Max;
					characterSpecs2.AddOrModifyValue("targetMaxHP", value.ToString());
					<lifePercentage>5__4 = 100f * Math.Min(Math.Max(<creatureData>5__3.Hp.Value, 0f) + (float)<>8__1.heal.total, <creatureData>5__3.Hp.Max) / <creatureData>5__3.Hp.Max;
					if (<lifePercentage>5__4 == 100f)
					{
						stack.AddOrModifyValue("targetState", "Unhurt");
					}
					else if (<lifePercentage>5__4 >= 75f)
					{
						stack.AddOrModifyValue("targetState", "Scratched");
					}
					else if (<lifePercentage>5__4 >= 50f)
					{
						stack.AddOrModifyValue("targetState", "Wounded");
					}
					else if (<lifePercentage>5__4 >= 25f)
					{
						stack.AddOrModifyValue("targetState", "Bloodied");
					}
					else if (<lifePercentage>5__4 >= 0f)
					{
						stack.AddOrModifyValue("targetState", "Critical");
					}
					else
					{
						stack.AddOrModifyValue("targetState", "Dying");
					}
					LoggingPlugin.LogInfo(instigator.Name + "'s " + check.name + " does " + <>8__1.heal.total + " points of healing");
					SendMessages("Heal", stack, instigator, target, publicity);
					CreatureManager.SetCreatureStatByIndex(target.CreatureId, new CreatureStat(Math.Min(Math.Max(<creatureData>5__3.Hp.Value, 0f) + (float)<>8__1.heal.total, <creatureData>5__3.Hp.Max), target.Hp.Max), -1);
					LoggingPlugin.LogDebug("Ended ProcessHealOnTarget...");
					return false;
				}
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <ProcessInstigatorRoll>d__16 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Characters.CharacterSpecs stack;

			public Characters.CharactersSpecs.CheckType action;

			public Characters.Spec check;

			public CreatureBoardAsset instigator;

			public MessagePublicity publicity;

			private <>c__DisplayClass16_0 <>8__1;

			private Characters.CharacterSpecs <instigatorSheet>5__2;

			private int <critOn>5__3;

			private string <co>5__4;

			private bool <crit>5__5;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <ProcessInstigatorRoll>d__16(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<instigatorSheet>5__2 = null;
				<co>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					LoggingPlugin.LogDebug("Starting ProcessInstigatorRoll...");
					if ((Object)(object)instigator != (Object)null)
					{
						<>8__1 = new <>c__DisplayClass16_0();
						LoggingPlugin.LogDebug("Instigator: " + instigator.Name);
						LoggingPlugin.LogTrace("Getting " + DiceRoller.StripTrailingInteger(instigator.Name) + " Sheet");
						<instigatorSheet>5__2 = _self.characters.FindFirst(DiceRoller.StripTrailingInteger(instigator.Name));
						<>8__1.rollResult = null;
						<>2__current = RollDice(<instigatorSheet>5__2, check.name, check.formula, delegate(DiceRoller.RollResult r)
						{
							<>8__1.rollResult = r;
						});
						<>1__state = 1;
						return true;
					}
					break;
				case 1:
					<>1__state = -1;
					LoggingPlugin.LogDebug("Instigator Roll: Name: " + <>8__1.rollResult.name);
					LoggingPlugin.LogDebug("Instigator Roll: Formula: " + <>8__1.rollResult.formula);
					LoggingPlugin.LogDebug("Instigator Roll: Roll: " + <>8__1.rollResult.formulaResolved);
					LoggingPlugin.LogDebug("Instigator Roll: Dice: " + <>8__1.rollResult.formulaDice);
					LoggingPlugin.LogDebug("Instigator Roll: Total: " + <>8__1.rollResult.total);
					<>2__current = ProcessExtensions(ExtensionType.instigatorSkillResult, instigator, null, <instigatorSheet>5__2, null, check, null, null, <>8__1.rollResult, delegate(DiceRoller.RollResult r)
					{
						<>8__1.rollResult = r;
					});
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					stack.AddOrModifyValue("instigatorName", instigator.Name);
					stack.AddOrModifyValue("name", <>8__1.rollResult.name);
					stack.AddOrModifyValue("formula", <>8__1.rollResult.formula);
					stack.AddOrModifyValue("roll", <>8__1.rollResult.formulaResolved);
					stack.AddOrModifyValue("dice", <>8__1.rollResult.formulaDice);
					stack.AddOrModifyValue("total", <>8__1.rollResult.total.ToString());
					LoggingPlugin.LogInfo(instigator.Name + "'s " + check.name + " = " + <>8__1.rollResult.total);
					LoggingPlugin.LogDebug("Setting up crit value");
					<co>5__4 = check.Extra("critOn");
					<critOn>5__3 = ((<co>5__4 != null) ? int.Parse(<co>5__4) : 20);
					<crit>5__5 = false;
					if (<>8__1.rollResult.dice != null && <>8__1.rollResult.dice.Length != 0)
					{
						<crit>5__5 = <>8__1.rollResult.dice[0] >= <critOn>5__3 && <critOn>5__3 > 0;
						LoggingPlugin.LogDebug("Die: " + <>8__1.rollResult.dice[0] + ", Crit On: " + <critOn>5__3 + ", Crit: " + <crit>5__5);
					}
					stack.AddOrModifyValue("crit", <crit>5__5.ToString());
					LoggingPlugin.LogDebug("Sending notifications");
					stack.AddOrModifyValue("instigatorName", instigator.Name);
					stack.AddOrModifyValue("name", <>8__1.rollResult.name);
					stack.AddOrModifyValue("formula", <>8__1.rollResult.formula);
					stack.AddOrModifyValue("roll", <>8__1.rollResult.formulaResolved);
					stack.AddOrModifyValue("dice", <>8__1.rollResult.formulaDice);
					stack.AddOrModifyValue("total", <>8__1.rollResult.total.ToString());
					SendMessages(action.ToString() + ".Instigation", stack, instigator, null, publicity);
					<>8__1 = null;
					<instigatorSheet>5__2 = null;
					<co>5__4 = null;
					break;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <ProcessSequence>d__15 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Characters.CharacterSpecs stack;

			public Characters.CharactersSpecs.CheckType action;

			public Characters.Spec check;

			public CreatureBoardAsset instigator;

			public CreatureBoardAsset[] targets;

			public MessagePublicity publicity;

			private bool <firstTarget>5__1;

			private CreatureBoardAsset[] <>s__2;

			private int <>s__3;

			private CreatureBoardAsset <target>5__4;

			private Characters.CharacterSpecs <instigatorSheet>5__5;

			private string <chain>5__6;

			private string <item>5__7;

			private string <menu>5__8;

			private string <item>5__9;

			private string <menu>5__10;

			private string <item>5__11;

			private string <menu>5__12;

			private object[] <parameters>5__13;

			private int <p>5__14;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <ProcessSequence>d__15(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>s__2 = null;
				<target>5__4 = null;
				<instigatorSheet>5__5 = null;
				<chain>5__6 = null;
				<item>5__7 = null;
				<menu>5__8 = null;
				<item>5__9 = null;
				<menu>5__10 = null;
				<item>5__11 = null;
				<menu>5__12 = null;
				<parameters>5__13 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00db: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e5: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					LoggingPlugin.LogInfo("--------------------------------------------------------------------------------");
					LoggingPlugin.LogInfo("  Started " + instigator.Name + "'s " + check.name + " (" + action.ToString() + ")");
					LoggingPlugin.LogInfo("--------------------------------------------------------------------------------");
					<>2__current = (object)new WaitForSeconds(0.1f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (action == Characters.CharactersSpecs.CheckType.Attack || action == Characters.CharactersSpecs.CheckType.Opposed || action == Characters.CharactersSpecs.CheckType.Regular)
					{
						<>2__current = ProcessInstigatorRoll(stack, action, check, instigator, publicity);
						<>1__state = 2;
						return true;
					}
					goto IL_018b;
				case 2:
					<>1__state = -1;
					if (action != Characters.CharactersSpecs.CheckType.Regular && (targets == null || targets.Length == 0))
					{
						LoggingPlugin.LogDebug("No Target Selected For Opposed Check. Processing As Regular Check.");
						action = Characters.CharactersSpecs.CheckType.Regular;
					}
					goto IL_018b;
				case 3:
					<>1__state = -1;
					if (int.Parse(stack.FindFirstValue("total")) >= int.Parse(stack.FindFirstValue("opposedTotal")))
					{
						stack.AddOrModifyValue("result", "Hit");
					}
					else if (check.Extra("half") != null)
					{
						stack.AddOrModifyValue("result", "Half");
					}
					else
					{
						stack.AddOrModifyValue("result", "Miss");
					}
					SendMessages(action.ToString() + "." + stack.FindFirstValue("result"), stack, instigator, null, publicity);
					if (action == Characters.CharactersSpecs.CheckType.Attack && stack.FindFirstValue("result").ToUpper() != "MISS")
					{
						<>2__current = AnimateAttack(check, instigator, <target>5__4, <firstTarget>5__1, success: true);
						<>1__state = 4;
						return true;
					}
					if (action == Characters.CharactersSpecs.CheckType.Attack)
					{
						<>2__current = AnimateAttack(check, instigator, <target>5__4, <firstTarget>5__1, success: false);
						<>1__state = 7;
						return true;
					}
					goto IL_04ca;
				case 4:
					<>1__state = -1;
					<>2__current = ProcessDamageOnTarget(stack, action, check, instigator, <target>5__4, stack.FindFirstValue("result"), publicity);
					<>1__state = 5;
					return true;
				case 5:
					<>1__state = -1;
					<>2__current = ProcessEffectOnTarget(stack, action, check, instigator, <target>5__4, stack.FindFirstValue("result"), publicity);
					<>1__state = 6;
					return true;
				case 6:
					<>1__state = -1;
					goto IL_04ca;
				case 7:
					{
						<>1__state = -1;
						goto IL_04ca;
					}
					IL_018b:
					if (targets == null)
					{
						break;
					}
					<firstTarget>5__1 = true;
					<>s__2 = targets;
					<>s__3 = 0;
					goto IL_088c;
					IL_088c:
					if (<>s__3 < <>s__2.Length)
					{
						<target>5__4 = <>s__2[<>s__3];
						LoggingPlugin.LogDebug("--------------------------------------------------------------------------------");
						LoggingPlugin.LogDebug("  Processing " + instigator.Name + "'s " + check.name + " Vs " + <target>5__4.Name);
						LoggingPlugin.LogDebug("--------------------------------------------------------------------------------");
						if (action == Characters.CharactersSpecs.CheckType.Attack || action == Characters.CharactersSpecs.CheckType.Opposed)
						{
							<>2__current = ProcessTargetRoll(stack, action, check, instigator, <target>5__4, publicity);
							<>1__state = 3;
							return true;
						}
						goto IL_04ca;
					}
					<>s__2 = null;
					break;
					IL_04ca:
					LoggingPlugin.LogDebug("Staring etting Instigator Sheet...");
					LoggingPlugin.LogDebug(instigator.Name);
					LoggingPlugin.LogDebug(DiceRoller.StripTrailingInteger(instigator.Name));
					<instigatorSheet>5__5 = _self.characters.FindFirst(DiceRoller.StripTrailingInteger(instigator.Name));
					LoggingPlugin.LogDebug("Ended Getting Instigator Sheet...");
					LoggingPlugin.LogDebug("Looking For Chains");
					<chain>5__6 = check.Extra("chainAlways");
					if (<chain>5__6 != null)
					{
						LoggingPlugin.LogDebug("Adding chainAlways chain: " + <chain>5__6);
						<item>5__7 = <chain>5__6.Substring(<chain>5__6.LastIndexOf("/") + 1);
						<menu>5__8 = <chain>5__6.Substring(0, <chain>5__6.LastIndexOf("/"));
						chainList.Add(new object[5]
						{
							<item>5__7,
							"/" + instigator.Name + <menu>5__8,
							new CreatureBoardAsset[1] { instigator },
							new CreatureBoardAsset[1] { <target>5__4 },
							publicity
						});
						<item>5__7 = null;
						<menu>5__8 = null;
					}
					else if (stack.FindFirstValue("result") == "Hit")
					{
						<chain>5__6 = check.Extra("chainSuccess");
						if (<chain>5__6 != null)
						{
							LoggingPlugin.LogDebug("Adding chainSuccess chain: " + <chain>5__6);
							<item>5__9 = <chain>5__6.Substring(<chain>5__6.LastIndexOf("/") + 1);
							<menu>5__10 = <chain>5__6.Substring(0, <chain>5__6.LastIndexOf("/"));
							chainList.Add(new object[5]
							{
								<item>5__9,
								"/" + instigator.Name + <menu>5__10,
								new CreatureBoardAsset[1] { instigator },
								new CreatureBoardAsset[1] { <target>5__4 },
								publicity
							});
							<item>5__9 = null;
							<menu>5__10 = null;
						}
					}
					else
					{
						<chain>5__6 = check.Extra("chainFailure");
						if (<chain>5__6 != null)
						{
							LoggingPlugin.LogDebug("Adding chainFailure chain: " + <chain>5__6);
							<item>5__11 = <chain>5__6.Substring(<chain>5__6.LastIndexOf("/") + 1);
							<menu>5__12 = <chain>5__6.Substring(0, <chain>5__6.LastIndexOf("/"));
							chainList.Add(new object[5]
							{
								<item>5__11,
								"/" + instigator.Name + <menu>5__12,
								new CreatureBoardAsset[1] { instigator },
								new CreatureBoardAsset[1] { <target>5__4 },
								publicity
							});
							<item>5__11 = null;
							<menu>5__12 = null;
						}
					}
					<firstTarget>5__1 = false;
					<instigatorSheet>5__5 = null;
					<chain>5__6 = null;
					<target>5__4 = null;
					<>s__3++;
					goto IL_088c;
				}
				if (chainList.Count > 0)
				{
					LoggingPlugin.LogDebug("Processing next chain");
					<parameters>5__13 = chainList.ElementAt(0);
					chainList.RemoveAt(0);
					<p>5__14 = 0;
					while (<p>5__14 <= 3)
					{
						LoggingPlugin.LogDebug("Parameter " + <p>5__14 + ": " + <parameters>5__13[<p>5__14].GetType()?.ToString() + ": " + <parameters>5__13[<p>5__14].ToString());
						<p>5__14++;
					}
					((MonoBehaviour)_self).StartCoroutine(Characters.InitiateMenuAction((string)<parameters>5__13[0], (string)<parameters>5__13[1], (CreatureBoardAsset[])<parameters>5__13[2], (CreatureBoardAsset[])<parameters>5__13[3]));
					<parameters>5__13 = null;
				}
				commonDamage = null;
				LoggingPlugin.LogTrace("--------------------------------------------------------------------------------");
				LoggingPlugin.LogTrace("  Completed " + instigator.Name + "'s " + check.name + " (" + action.ToString() + ")");
				LoggingPlugin.LogTrace("--------------------------------------------------------------------------------");
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <ProcessTargetRoll>d__17 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Characters.CharacterSpecs stack;

			public Characters.CharactersSpecs.CheckType action;

			public Characters.Spec instigatorCheck;

			public CreatureBoardAsset instigator;

			public CreatureBoardAsset target;

			public MessagePublicity publicity;

			private <>c__DisplayClass17_0 <>8__1;

			private string <opposedList>5__2;

			private string <opposed>5__3;

			private Characters.CharacterSpecs <instigatorSheet>5__4;

			private Characters.CharacterSpecs <targetSheet>5__5;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <ProcessTargetRoll>d__17(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<opposedList>5__2 = null;
				<opposed>5__3 = null;
				<instigatorSheet>5__4 = null;
				<targetSheet>5__5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					LoggingPlugin.LogDebug("Starting ProcessTargetRoll...");
					if ((Object)(object)target != (Object)null)
					{
						<>8__1 = new <>c__DisplayClass17_0();
						LoggingPlugin.LogDebug("Target: " + target.Name);
						<opposed>5__3 = instigatorCheck.Extra("opposed");
						<opposedList>5__2 = ((<opposed>5__3 != null) ? <opposed>5__3 : "AC");
						LoggingPlugin.LogDebug(instigatorCheck.name + " is opposed by " + <opposedList>5__2);
						waitingOnRemoteAction = true;
						<>8__1.opposedRoll = null;
						<>2__current = QueryRemotes(new RemoteQuerySpecs
						{
							name = target.Name,
							item = <opposedList>5__2
						}, new TaskCompletionSource<List<RemoteQueryResponse>>(), null, null, 1, 0, delegate(DiceRoller.RollResult r)
						{
							<>8__1.opposedRoll = r;
						});
						<>1__state = 1;
						return true;
					}
					break;
				case 1:
					<>1__state = -1;
					waitingOnRemoteAction = false;
					stack.AddOrModifyValue("targetName", target.Name);
					stack.AddOrModifyValue("opposedName", <>8__1.opposedRoll.name);
					stack.AddOrModifyValue("opposedFormula", <>8__1.opposedRoll.formula);
					stack.AddOrModifyValue("opposedRoll", <>8__1.opposedRoll.formulaResolved);
					stack.AddOrModifyValue("opposedDice", <>8__1.opposedRoll.formulaDice);
					stack.AddOrModifyValue("opposedTotal", <>8__1.opposedRoll.total.ToString());
					<instigatorSheet>5__4 = _self.characters.FindFirst(DiceRoller.StripTrailingInteger(instigator.Name));
					<targetSheet>5__5 = _self.characters.FindFirst(DiceRoller.StripTrailingInteger(target.Name));
					<>2__current = ProcessExtensions(ExtensionType.targetSkillResult, instigator, target, <instigatorSheet>5__4, <targetSheet>5__5, instigatorCheck, <>8__1.opposedRoll.name, null, <>8__1.opposedRoll, delegate(DiceRoller.RollResult r)
					{
						<>8__1.opposedRoll = r;
					});
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					stack.AddOrModifyValue("opposedName", <>8__1.opposedRoll.name);
					stack.AddOrModifyValue("opposedFormula", <>8__1.opposedRoll.formula);
					stack.AddOrModifyValue("opposedRoll", <>8__1.opposedRoll.formulaResolved);
					stack.AddOrModifyValue("opposedDice", <>8__1.opposedRoll.formulaDice);
					stack.AddOrModifyValue("opposedTotal", <>8__1.opposedRoll.total.ToString());
					LoggingPlugin.LogInfo(target.Name + "'s " + <>8__1.opposedRoll.name + " = " + <>8__1.opposedRoll.total);
					SendMessages(action.ToString() + ".Opposition", stack, instigator, target, publicity);
					<>8__1 = null;
					<opposedList>5__2 = null;
					<opposed>5__3 = null;
					<instigatorSheet>5__4 = null;
					<targetSheet>5__5 = null;
					break;
				}
				LoggingPlugin.LogDebug("Ended ProcessTargetRoll...");
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <QueryRemotes>d__12 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public RemoteQuerySpecs query;

			public TaskCompletionSource<List<RemoteQueryResponse>> token;

			public string[] specificClients;

			public string[] specificPlayers;

			public int expectedResults;

			public int expectedResultsTimeout;

			public Action<DiceRoller.RollResult> onComplete;

			private <>c__DisplayClass12_0 <>8__1;

			private DiceRoller.RollResult <queryTaskRollResult>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <QueryRemotes>d__12(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<queryTaskRollResult>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_007b: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass12_0();
					<>8__1.queryTask = RemoteQuery.MakeRequest(query, token, specificClients, specificPlayers, expectedResults, expectedResultsTimeout);
					<>2__current = (object)new WaitUntil((Func<bool>)(() => <>8__1.queryTask.IsCompleted));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<queryTaskRollResult>5__2 = JsonConvert.DeserializeObject<List<DiceRoller.RollResult>>(<>8__1.queryTask.Result[0].response).ToArray()[0];
					onComplete?.Invoke(<queryTaskRollResult>5__2);
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <QueryRemotesForDamage>d__13 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public RemoteQuerySpecs query;

			public TaskCompletionSource<List<RemoteQueryResponse>> token;

			public string[] specificClients;

			public string[] specificPlayers;

			public int expectedResults;

			public int expectedResultsTimeout;

			public Action<string> onComplete;

			private <>c__DisplayClass13_0 <>8__1;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <QueryRemotesForDamage>d__13(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_007b: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass13_0();
					<>8__1.queryTask = RemoteQuery.MakeRequest(query, token, specificClients, specificPlayers, expectedResults, expectedResultsTimeout);
					<>2__current = (object)new WaitUntil((Func<bool>)(() => <>8__1.queryTask.IsCompleted));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					onComplete?.Invoke(<>8__1.queryTask.Result[0].response);
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <RollDice>d__14 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Characters.CharacterSpecs instigatorSheet;

			public string rollName;

			public string rollFormula;

			public Action<DiceRoller.RollResult> onComplete;

			private <>c__DisplayClass14_0 <>8__1;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <RollDice>d__14(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0069: Unknown result type (might be due to invalid IL or missing references)
				//IL_0073: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass14_0();
					<>8__1.rollTask = DiceRoller.Roll(instigatorSheet, rollName, rollFormula, rollingStyleOffensive);
					<>2__current = (object)new WaitUntil((Func<bool>)(() => <>8__1.rollTask.IsCompleted));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					onComplete?.Invoke(<>8__1.rollTask.Result);
					return false;
				}
			}

			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 static List<Script> scripts = new List<Script>();

		public static DiceRoller.RollResult commonDamage = null;

		public static bool waitingOnRemoteAction = false;

		public static List<object[]> chainList = new List<object[]>();

		private static Dictionary<ExtensionType, List<ToggleCallaback>> extensions = new Dictionary<ExtensionType, List<ToggleCallaback>>();

		public static void LoadScripts()
		{
			string text = File.ReadAllText("org.lordashes.plugins.d20.scripts.json", (CacheType)999);
			text = text.TrimStart('\ufeff', '\u200b');
			scripts = JsonConvert.DeserializeObject<List<Script>>(text);
			LoggingPlugin.LogInfo("Loaded " + scripts.Count + " Scripts");
			foreach (ExtensionType value in Enum.GetValues(typeof(ExtensionType)))
			{
				if (!extensions.ContainsKey(value))
				{
					extensions.Add(value, new List<ToggleCallaback>());
				}
			}
		}

		public static void RegisterExtension(ToggleRequired toggleOnWho, ExtensionType extensionType, string toggleName, Func<CreatureBoardAsset, CreatureBoardAsset, Characters.CharacterSpecs, Characters.CharacterSpecs, Characters.Spec, string, Characters.Spec, DiceRoller.RollResult, Task<DiceRoller.RollResult>> callback)
		{
			if (!extensions.ContainsKey(extensionType))
			{
				extensions.Add(extensionType, new List<ToggleCallaback>());
			}
			extensions[extensionType].Add(new ToggleCallaback
			{
				toggleName = toggleName,
				callback = callback
			});
		}

		[IteratorStateMachine(typeof(<ProcessExtensions>d__11))]
		public static IEnumerator ProcessExtensions(ExtensionType extensionType, CreatureBoardAsset instigator, CreatureBoardAsset target, Characters.CharacterSpecs instigatorSheet, Characters.CharacterSpecs targetSheet, Characters.Spec instigatorCheck, string targetCheck, Characters.Spec spec, DiceRoller.RollResult rollResult, Action<DiceRoller.RollResult> onComplete)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ProcessExtensions>d__11(0)
			{
				extensionType = extensionType,
				instigator = instigator,
				target = target,
				instigatorSheet = instigatorSheet,
				targetSheet = targetSheet,
				instigatorCheck = instigatorCheck,
				targetCheck = targetCheck,
				spec = spec,
				rollResult = rollResult,
				onComplete = onComplete
			};
		}

		[IteratorStateMachine(typeof(<QueryRemotes>d__12))]
		private static IEnumerator QueryRemotes(RemoteQuerySpecs query, TaskCompletionSource<List<RemoteQueryResponse>> token, string[] specificClients, string[] specificPlayers, int expectedResults, int expectedResultsTimeout, Action<DiceRoller.RollResult> onComplete)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <QueryRemotes>d__12(0)
			{
				query = query,
				token = token,
				specificClients = specificClients,
				specificPlayers = specificPlayers,
				expectedResults = expectedResults,
				expectedResultsTimeout = expectedResultsTimeout,
				onComplete = onComplete
			};
		}

		[IteratorStateMachine(typeof(<QueryRemotesForDamage>d__13))]
		private static IEnumerator QueryRemotesForDamage(RemoteQuerySpecs query, TaskCompletionSource<List<RemoteQueryResponse>> token, string[] specificClients, string[] specificPlayers, int expectedResults, int expectedResultsTimeout, Action<string> onComplete)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <QueryRemotesForDamage>d__13(0)
			{
				query = query,
				token = token,
				specificClients = specificClients,
				specificPlayers = specificPlayers,
				expectedResults = expectedResults,
				expectedResultsTimeout = expectedResultsTimeout,
				onComplete = onComplete
			};
		}

		[IteratorStateMachine(typeof(<RollDice>d__14))]
		private static IEnumerator RollDice(Characters.CharacterSpecs instigatorSheet, string rollName, string rollFormula, Action<DiceRoller.RollResult> onComplete)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <RollDice>d__14(0)
			{
				instigatorSheet = instigatorSheet,
				rollName = rollName,
				rollFormula = rollFormula,
				onComplete = onComplete
			};
		}

		[IteratorStateMachine(typeof(<ProcessSequence>d__15))]
		public static IEnumerator ProcessSequence(Characters.CharacterSpecs stack, Characters.CharactersSpecs.CheckType action, Characters.Spec check, CreatureBoardAsset instigator, CreatureBoardAsset[] targets, MessagePublicity publicity)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ProcessSequence>d__15(0)
			{
				stack = stack,
				action = action,
				check = check,
				instigator = instigator,
				targets = targets,
				publicity = publicity
			};
		}

		[IteratorStateMachine(typeof(<ProcessInstigatorRoll>d__16))]
		public static IEnumerator ProcessInstigatorRoll(Characters.CharacterSpecs stack, Characters.CharactersSpecs.CheckType action, Characters.Spec check, CreatureBoardAsset instigator, MessagePublicity publicity)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ProcessInstigatorRoll>d__16(0)
			{
				stack = stack,
				action = action,
				check = check,
				instigator = instigator,
				publicity = publicity
			};
		}

		[IteratorStateMachine(typeof(<ProcessTargetRoll>d__17))]
		public static IEnumerator ProcessTargetRoll(Characters.CharacterSpecs stack, Characters.CharactersSpecs.CheckType action, Characters.Spec instigatorCheck, CreatureBoardAsset instigator, CreatureBoardAsset target, MessagePublicity publicity)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ProcessTargetRoll>d__17(0)
			{
				stack = stack,
				action = action,
				instigatorCheck = instigatorCheck,
				instigator = instigator,
				target = target,
				publicity = publicity
			};
		}

		[IteratorStateMachine(typeof(<ProcessDamageOnTarget>d__18))]
		public static IEnumerator ProcessDamageOnTarget(Characters.CharacterSpecs stack, Characters.CharactersSpecs.CheckType action, Characters.Spec check, CreatureBoardAsset instigator, CreatureBoardAsset target, string severity, MessagePublicity publicity, string overrideDamage = null)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ProcessDamageOnTarget>d__18(0)
			{
				stack = stack,
				action = action,
				check = check,
				instigator = instigator,
				target = target,
				severity = severity,
				publicity = publicity,
				overrideDamage = overrideDamage
			};
		}

		[IteratorStateMachine(typeof(<ProcessEffectOnTarget>d__19))]
		public static IEnumerator ProcessEffectOnTarget(Characters.CharacterSpecs stack, Characters.CharactersSpecs.CheckType action, Characters.Spec check, CreatureBoardAsset instigator, CreatureBoardAsset target, string severity, MessagePublicity publicity, string overrideEffect = null)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ProcessEffectOnTarget>d__19(0)
			{
				stack = stack,
				action = action,
				check = check,
				instigator = instigator,
				target = target,
				severity = severity,
				publicity = publicity,
				overrideEffect = overrideEffect
			};
		}

		[IteratorStateMachine(typeof(<ProcessHealOnTarget>d__20))]
		public static IEnumerator ProcessHealOnTarget(Characters.CharacterSpecs stack, Characters.CharactersSpecs.CheckType action, Characters.Spec check, CreatureBoardAsset instigator, CreatureBoardAsset target, MessagePublicity publicity)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ProcessHealOnTarget>d__20(0)
			{
				stack = stack,
				action = action,
				check = check,
				instigator = instigator,
				target = target,
				publicity = publicity
			};
		}

		[IteratorStateMachine(typeof(<ProcessGeneric>d__21))]
		public static IEnumerator ProcessGeneric(Characters.CharacterSpecs stack, Characters.CharactersSpecs.CheckType action, Characters.Spec check, CreatureBoardAsset instigator, CreatureBoardAsset target, MessagePublicity publicity)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ProcessGeneric>d__21(0)
			{
				stack = stack,
				action = action,
				check = check,
				instigator = instigator,
				target = target,
				publicity = publicity
			};
		}

		[IteratorStateMachine(typeof(<AnimateAttack>d__22))]
		public static IEnumerator AnimateAttack(Characters.Spec check, CreatureBoardAsset instigator, CreatureBoardAsset target, bool firstTarget, bool success)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AnimateAttack>d__22(0)
			{
				check = check,
				instigator = instigator,
				target = target,
				firstTarget = firstTarget,
				success = success
			};
		}

		[IteratorStateMachine(typeof(<DelayedCreatureRemove>d__23))]
		private static IEnumerator DelayedCreatureRemove(CreatureGuid cid, float removeDeadMinisAfterSeconds)
		{
			//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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DelayedCreatureRemove>d__23(0)
			{
				cid = cid,
				removeDeadMinisAfterSeconds = removeDeadMinisAfterSeconds
			};
		}

		public static void SendMessages(string scriptName, Characters.CharacterSpecs stack, CreatureBoardAsset instigator, CreatureBoardAsset target, MessagePublicity publicity)
		{
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Unknown result type (might be due to invalid IL or missing references)
			//IL_0425: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			//IL_027d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0283: Unknown result type (might be due to invalid IL or missing references)
			//IL_030e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0313: Unknown result type (might be due to invalid IL or missing references)
			//IL_031b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0322: Unknown result type (might be due to invalid IL or missing references)
			//IL_0472: Unknown result type (might be due to invalid IL or missing references)
			//IL_0477: Unknown result type (might be due to invalid IL or missing references)
			//IL_047c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0337: Unknown result type (might be due to invalid IL or missing references)
			//IL_033b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0341: Unknown result type (might be due to invalid IL or missing references)
			//IL_049d: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ce: Unknown result type (might be due to invalid IL or missing references)
			LoggingPlugin.LogDebug("Starting SendMessage...");
			Script script = scripts.Where((Script s) => s.use == scriptName).FirstOrDefault();
			if (script == null)
			{
				LoggingPlugin.LogDebug("Script '" + scriptName + "' Not Found.");
				return;
			}
			Characters.CharacterSpecs sheet = _self.characters.FindFirst(DiceRoller.StripTrailingInteger(instigator.Name));
			string text = "";
			if (publicity != MessagePublicity.privateMessage)
			{
				LoggingPlugin.LogDebug("Sending Instigator Text");
				if ((Object)(object)instigator != (Object)null && script.instigator_speech != null && script.instigator_speech.Trim() != "")
				{
					text = CheckForChoice(ResolvePlaceHolders(stack, script.instigator_speech));
					text = CheckForChoice(ResolvePlaceHolders(sheet, text));
					instigator.Speak(CheckForChoice(ResolvePlaceHolders(stack, text)));
				}
				LoggingPlugin.LogDebug("Sending Target Text");
				if ((Object)(object)target != (Object)null && script.target_speech != null && script.target_speech.Trim() != "")
				{
					text = CheckForChoice(ResolvePlaceHolders(stack, script.target_speech));
					text = CheckForChoice(ResolvePlaceHolders(sheet, text));
					target.Speak(CheckForChoice(ResolvePlaceHolders(stack, text)));
				}
			}
			LoggingPlugin.LogDebug("Sending GM Notification");
			if (script.gm != null && script.gm.Trim() != "")
			{
				text = CheckForChoice(ResolvePlaceHolders(stack, script.gm));
				ChatManager.SendChatMessageToGms(ResolvePlaceHolders(stack, text), default(NGuid), (float3?)null, false);
			}
			if (publicity != MessagePublicity.privateMessage)
			{
				LoggingPlugin.LogDebug("Sending Instigator Notification");
				if ((Object)(object)instigator != (Object)null && script.instigator != null && script.instigator.Trim() != "")
				{
					text = CheckForChoice(ResolvePlaceHolders(stack, script.instigator));
					PlayerGuid[] owners = GetOwners(instigator.CreatureId);
					foreach (PlayerGuid val in owners)
					{
						if (!CampaignSessionManager.PlayersInfo[val].Rights.CanGm)
						{
							ChatManager.SendChatMessageToPlayer(text, val, default(NGuid), (float3?)null, false);
						}
					}
				}
				LoggingPlugin.LogDebug("Sending Target Notification");
				if ((Object)(object)target != (Object)null && script.target != null && script.target.Trim() != "")
				{
					text = CheckForChoice(ResolvePlaceHolders(stack, script.target));
					PlayerGuid[] owners2 = GetOwners(target.CreatureId);
					foreach (PlayerGuid val2 in owners2)
					{
						if (!CampaignSessionManager.PlayersInfo[val2].Rights.CanGm)
						{
							ChatManager.SendChatMessageToPlayer(text, val2, default(NGuid), (float3?)null, false);
						}
					}
				}
			}
			if (publicity == MessagePublicity.publicMessage)
			{
				LoggingPlugin.LogDebug("Sending Other Notification");
				if (script.others != null && script.others.Trim() != "")
				{
					text = CheckForChoice(ResolvePlaceHolders(stack, script.others));
					text = CheckForChoice(ResolvePlaceHolders(sheet, text));
					LoggingPlugin.LogTrace("Getting Exclusion List");
					List<PlayerGuid> list = new List<PlayerGuid>();
					if ((Object)(object)instigator != (Object)null)
					{
						PlayerGuid[] owners3 = GetOwners(instigator.CreatureId);
						if (owners3 != null && owners3.Length != 0)
						{
							list.AddRange(owners3);
						}
					}
					if ((Object)(object)target != (Object)null)
					{
						PlayerGuid[] owners4 = GetOwners(target.CreatureId);
						if (owners4 != null && owners4.Length != 0)
						{
							list.AddRange(owners4);
						}
					}
					LoggingPlugin.LogTrace("Processing Player List");
					foreach (PlayerGuid key in CampaignSessionManager.PlayersInfo.Keys)
					{
						if (!list.Contains(key))
						{
							LoggingPlugin.LogTrace("Check If Player Not GM");
							if (!CampaignSessionManager.PlayersInfo[key].Rights.CanGm)
							{
								LoggingPlugin.LogTrace("Sending Player Notifcation");
								ChatManager.SendChatMessageToPlayer(text, key, default(NGuid), (float3?)null, false);
							}
						}
					}
				}
			}
			LoggingPlugin.LogTrace("Sending Notifications Complete");
			LoggingPlugin.LogDebug("Ended SendMessage...");
		}

		public static void SpeakMessage(CreatureBoardAsset speaker, Characters.CharacterSpecs sheet, string message)
		{
			if ((Object)(object)speaker != (Object)null)
			{
				string msg = CheckForChoice(ResolvePlaceHolders(sheet, message));
				speaker.Speak(CheckForChoice(ResolvePlaceHolders(sheet, msg)));
			}
		}

		public static void ChatMessage(CreatureBoardAsset speaker, Characters.CharacterSpecs sheet, string message)
		{
			//IL_001f: 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_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: 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_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: 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_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)speaker != (Object)null))
			{
				return;
			}
			string text = CheckForChoice(ResolvePlaceHolders(sheet, message));
			PlayerGuid[] owners = GetOwners(speaker.CreatureId);
			foreach (PlayerGuid val in owners)
			{
				if (!CampaignSessionManager.PlayersInfo[val].Rights.CanGm)
				{
					ChatManager.SendChatMessageToPlayer(text, val, speaker.CreatureId.Value, (float3?)null, false);
				}
			}
			ChatManager.SendChatMessageToGms(text, speaker.CreatureId.Value, (float3?)null, false);
		}

		public static void LogMessage(DiagnosticLevel level, string msg)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Invalid comparison between Unknown and I4
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Invalid comparison between Unknown and I4
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Invalid comparison between Unknown and I4
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Invalid comparison between Unknown and I4
			if ((int)level == 1)
			{
				LoggingPlugin.LogError(msg);
			}
			else if ((int)level == 2)
			{
				LoggingPlugin.LogWarning(msg);
			}
			else if ((int)level == 3)
			{
				LoggingPlugin.LogInfo(msg);
			}
			else if ((int)level == 4)
			{
				LoggingPlugin.LogDebug(msg);
			}
			else if ((int)level == 5)
			{
				LoggingPlugin.LogTrace(msg);
			}
		}

		private static string CheckForChoice(string msg)
		{
			if (msg.ToUpper().StartsWith("CHOICE:"))
			{
				Random random = new Random();
				msg = msg.Substring("CHOICE:".Length);
				string[] array = msg.Split(new char[1] { '|' });
				int num = random.Next(0, array.Length);
				msg = array[num];
				LoggingPlugin.LogTrace("Choice (" + (num + 1) + " of " + array.Length + ") = " + msg);
			}
			else
			{
				LoggingPlugin.LogTrace("Choice (None) = " + msg);
			}
			return msg;
		}

		private static string ResolvePlaceHolders(Characters.CharacterSpecs sheet, string msg)
		{
			while (msg.Contains("["))
			{
				string text = msg.Substring(msg.IndexOf("[") + 1);
				text = text.Substring(0, text.IndexOf("]"));
				string text2 = sheet.Resolve("[" + text + "]", 1);
				text = "[" + text + "]";
				msg = msg.Replace(text, text2.Replace("[", "{"));
			}
			return msg.Replace("{", "[").Replace("}", "]");
		}

		private static PlayerGuid[] GetOwners(CreatureGuid cid)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			LoggingPlugin.LogDebug("Getting Owners For Creature " + ((object)(CreatureGuid)(ref cid)).ToString());
			List<PlayerGuid> list = new List<PlayerGuid>();
			foreach (PlayerGuid key in CampaignSessionManager.PlayersInfo.Keys)
			{
				PlayerGuid current = key;
				LoggingPlugin.LogTrace("Checking Player " + ((object)(PlayerGuid)(ref current)).ToString());
				CreatureGuid[] array = null;
				LoggingPlugin.LogTrace("Getting Creatures Owned By Player " + ((object)(PlayerGuid)(ref current)).ToString());
				CreatureManager.TryGetPlayerOwnedCreatureIds(current, ref array);
				LoggingPlugin.LogTrace("Player Owns " + ((array == null) ? "Zero" : array.Length.ToString()) + " Creatures");
				if (array != null)
				{
					LoggingPlugin.LogTrace("Checking If Owned Creatures Includes " + ((object)(CreatureGuid)(ref cid)).ToString());
					if (IReadOnlyListExtensions.Contains<CreatureGuid>((IReadOnlyList<CreatureGuid>)array, cid))
					{
						LoggingPlugin.LogTrace("Adding Player To Owning Players List");
						list.Add(current);
						LoggingPlugin.LogTrace("Added Player To Owning Players List");
					}
				}
				LoggingPlugin.LogTrace("Players " + ((object)(PlayerGuid)(ref current)).ToString() + " Resolved");
			}
			LoggingPlugin.LogTrace("That is all the players checked. Returning result with " + list.Count + " entries");
			return list.ToArray();
		}
	}

	public static class Utility
	{
		public static bool isBoardLoaded()
		{
			return SimpleSingletonBehaviour<CameraController>.HasInstance && SingletonStateMBehaviour<BoardSessionManager, State<BoardSessionManager>>.HasInstance && !BoardSessionManager.IsLoading;
		}

		public static float ParseFloat(string value)
		{
			return float.Parse(value, CultureInfo.InvariantCulture);
		}

		public static GameObject FindInHierarchy(GameObject start, string seekName)
		{
			List<GameObject> results = new List<GameObject>();
			bool done = false;
			Traverse(start.transform, seekName, null, single: true, ref results, ref done);
			return (results.Count > 0) ? results.ElementAt(0) : null;
		}

		public static GameObject FindInHierarchyViaPartialName(GameObject start, string seekName)
		{
			List<GameObject> results = new List<GameObject>();
			bool done = false;
			Traverse(start.transform, seekName, null, single: true, ref results, ref done, partial: true);
			return (results.Count > 0) ? results.ElementAt(0) : null;
		}

		public static GameObject[] FindAllInHierarchy(GameObject start, string seekName)
		{
			List<GameObject> results = new List<GameObject>();
			bool done = false;
			Traverse(start.transform, seekName, null, single: false, ref results, ref done);
			return results.ToArray();
		}

		public static GameObject[] FindAllInHierarchyViaPartialName(GameObject start, string seekName)
		{
			List<GameObject> results = new List<GameObject>();
			bool done = false;
			Traverse(start.transform, seekName, null, single: false, ref results, ref done, partial: true);
			return results.ToArray();
		}

		public static GameObject FindWithComponentInHierarchy(GameObject start, string seekType)
		{
			List<GameObject> results = new List<GameObject>();
			bool done = false;
			Traverse(start.transform, null, seekType, single: true, ref results, ref done);
			return (results.Count > 0) ? results.ElementAt(0) : null;
		}

		public static GameObject[] FindAllWithComponentInHierarchy<T>(GameObject start, string seekType)
		{
			List<GameObject> results = new List<GameObject>();
			bool done = false;
			Traverse(start.transform, null, seekType, single: false, ref results, ref done);
			return results.ToArray();
		}

		public static void Traverse(Transform root, string seekName, string seekType, bool single, ref List<GameObject> results, ref bool done, bool partial = false)
		{
			try
			{
				if ((seekName == null || seekName == ((Object)((Component)root).gameObject).name || (partial && ((Object)((Component)root).gameObject).name.Contains(seekName))) && (seekType == null || (Object)(object)((Component)root).GetComponent(seekType) != (Object)null))
				{
					LoggingPlugin.LogTrace("Matched '" + ((Object)((Component)root).gameObject).name + "'");
					results.Add(((Component)root).gameObject);
					if (single)
					{
						done = true;
						return;
					}
				}
				foreach (Transform item in ExtensionMethods.Children(root))
				{
					if (!done)
					{
						Traverse(item, seekName, seekType, single, ref results, ref done, partial);
					}
				}
			}
			catch
			{
			}
		}

		public static object LookUp(in Dictionary<string, object> dictionary, string key)
		{
			foreach (KeyValuePair<string, object> item in dictionary)
			{
				if (item.Key.ToUpper() == key.ToUpper())
				{
					return item.Value;
				}
			}
			return null;
		}

		public static void PostOnMainPage(BaseUnityPlugin plugin)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			string text = "Lord Ashes" + ("Lord Ashes".ToUpper().EndsWith("S") ? "'" : "'s");
			ModdingUtils.Initialize(plugin, new ManualLogSource("D20 Plugin"), text, false);
		}
	}

	public enum AnimEnum
	{
		TLA_Wiggle,
		TLA_Twirl,
		TLA_Surprise,
		TLA_Action_Knockdown,
		TLA_MeleeAttack,
		TLA_MagicMissileAttack,
		TLA_Poison,
		TLA_PersistentGhost,
		TLA_Sleep
	}

	public class AssetTarget
	{
		public CreatureBoardAsset asset { get; set; }

		public bool selected { get; set; }

		public int distance { get; set; }
	}

	[CompilerGenerated]
	private sealed class <WarnAboutLogLevel>d__65 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public PluginD20 <>4__this;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <WarnAboutLogLevel>d__65(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			//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)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			try
			{
				DiagnosticLevel logLevel = LoggingPlugin.GetLogLevel();
				SystemMessage.DisplayInfoText("D20 Plugin: Using '" + ((object)(DiagnosticLevel)(ref logLevel)).ToString() + "' diagnostics.\r\nUse 'Info' for better performance", 10f, 0f, (Action)null);
				SystemMessage.DisplayInfoText("D20 Plugin: Use 'Debug' or 'Trace' for\r\ntroubleshooting only.", 10f, 0f, (Action)null);
			}
			catch
			{
				goto IL_0074;
			}
			return false;
			IL_0074:
			<>2__current = (object)new WaitForSeconds(1f);
			<>1__state = 1;
			return true;
		}

		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 static TargetsCollection targetsCollection = new TargetsCollection();

	public static bool collectingInitiative = false;

	private static SortedDictionary<int, QueueElement> initiativeOrder = new SortedDictionary<int, QueueElement>(Comparer<int>.Create((int a, int b) => b.CompareTo(a)));

	private static Dictionary<int, string> rulerTypes = new Dictionary<int, string>
	{
		{ 0, "Sphere" },
		{ 1, "Line" },
		{ 2, "Cone" },
		{ 3, "Box" }
	};

	private static string collecting = "";

	private static Dictionary<Guid, List<RemoteQueryResponse>> results = new Dictionary<Guid, List<RemoteQueryResponse>>();

	public const string Name = "D20 Plugin";

	public const string Guid = "org.lordashes.plugins.d20";

	public const string Version = "2.5.0.0";

	public const string Author = "Lord Ashes";

	public static PluginD20 _self = null;

	public Characters.CharactersSpecs characters = new Characters.CharactersSpecs();

	public static bool menuEditOpen = false;

	public static bool menuTargetPanelOpen = false;

	public static List<AssetTarget> targets = new List<AssetTarget>();

	private static Texture2D backdrop = null;

	private static int nestedResolve = 3;

	private static GameInput gameInputInstance = null;

	private static MethodInfo gameInputDisable = null;

	private static MethodInfo gameInputEnable = null;

	private static GUIStyle labelUI = new GUIStyle();

	private static KeyboardShortcut toggleMenu;

	private static KeyboardShortcut toggleTargetPanel;

	private static KeyboardShortcut toggleReload;

	private static ConfigEntry<bool> useAnimations;

	private static ConfigEntry<AttackEmotes> hitMeleeAnimation;

	private static ConfigEntry<AttackEmotes> hitRangedAnimation;

	private static ConfigEntry<AnimEnum> missAnimation;

	private static ConfigEntry<AnimEnum> deadAnimation;

	private static DiceRoller.RollingMethod rollingStyleOffensive;

	private static DiceRoller.RollingMethod rollingStyleDefensive;

	private static float removeDeadMinisAfterSeconds;

	private static bool summarizeInitiative;

	public static string pluginFolder = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);

	private static int lastMenuSize = 0;

	public static Dictionary<string, Projectile> projectiles = new Dictionary<string, Projectile>();

	private void Awake()
	{
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0076: 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)
		//IL_0086: 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_00b0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d4: 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)
		//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_0248: Unknown result type (might be due to invalid IL or missing references)
		//IL_025d: Unknown result type (might be due to invalid IL or missing references)
		//IL_026d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0273: Expected O, but got Unknown
		//IL_0395: Unknown result type (might be due to invalid IL or missing references)
		//IL_039b: Invalid comparison between Unknown and I4
		_self = this;
		LoggingPlugin.SetLogLevel(((BaseUnityPlugin)this).Config.Bind<DiagnosticLevel>("Settings", "Diagnostic Level", (DiagnosticLevel)3, (ConfigDescription)null).Value);
		string? assemblyQualifiedName = ((object)this).GetType().AssemblyQualifiedName;
		DiagnosticLevel logLevel = LoggingPlugin.GetLogLevel();
		LoggingPlugin.LogInfo(assemblyQualifiedName + ": Active. (Diagnostic Mode = " + ((object)(DiagnosticLevel)(ref logLevel)).ToString() + ")");
		toggleMenu = ((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("Hotkeys", "Toggle Menu", new KeyboardShortcut((KeyCode)282, Array.Empty<KeyCode>()), (ConfigDescription)null).Value;
		toggleTargetPanel = ((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("Hotkeys", "Toggle Target Panel", new KeyboardShortcut((KeyCode)283, Array.Empty<KeyCode>()), (ConfigDescription)null).Value;
		toggleReload = ((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("Hotkeys", "Reload Character Sheets", new KeyboardShortcut((KeyCode)284, Array.Empty<KeyCode>()), (ConfigDescription)null).Value;
		rollingStyleOffensive = ((BaseUnityPlugin)this).Config.Bind<DiceRoller.RollingMethod>("Settings", "Offensive Rolling Style", DiceRoller.RollingMethod.randomGeneratorDice, (ConfigDescription)null).Value;
		rollingStyleDefensive = ((BaseUnityPlugin)this).Config.Bind<DiceRoller.RollingMethod>("Settings", "Defensive Rolling Style", DiceRoller.RollingMethod.randomGeneratorDice, (ConfigDescription)null).Value;
		removeDeadMinisAfterSeconds = ((BaseUnityPlugin)this).Config.Bind<float>("Settings", "Remove Dead Minis After Seconds Or 0 For Never", 2f, (ConfigDescription)null).Value;
		summarizeInitiative = ((BaseUnityPlugin)this).Config.Bind<bool>("Settings", "Summarize Initiative", false, (ConfigDescription)null).Value;
		nestedResolve = ((BaseUnityPlugin)this).Config.Bind<int>("Settings", "Max Resolution Nested Levels", 3, (ConfigDescription)null).Value;
		useAnimations = ((BaseUnityPlugin)this).Config.Bind<bool>("Animations", "Use Animations", true, (ConfigDescription)null);
		hitMeleeAnimation = ((BaseUnityPlugin)this).Config.Bind<AttackEmotes>("Animations", "Hit Melee Animation", (AttackEmotes)0, (ConfigDescription)null);
		hitRangedAnimation = ((BaseUnityPlugin)this).Config.Bind<AttackEmotes>("Animations", "Hit Ranged Animation", (AttackEmotes)1, (ConfigDescription)null);
		missAnimation = ((BaseUnityPlugin)this).Config.Bind<AnimEnum>("Animations", "Miss Animation", AnimEnum.TLA_Wiggle, (ConfigDescription)null);
		deadAnimation = ((BaseUnityPlugin)this).Config.Bind<AnimEnum>("Animations", "Dead Animation", AnimEnum.TLA_Action_Knockdown, (ConfigDescription)null);
		backdrop = Image.LoadTexture("org.lordashes.plugins.d20.backdrop.png", (CacheType)999);
		labelUI.alignment = (TextAnchor)5;
		labelUI.active.textColor = Color.white;
		labelUI.normal.textColor = Color.white;
		Harmony val = new Harmony("org.lordashes.plugins.d20");
		val.PatchAll();
		try
		{
			LoggingPlugin.LogDebug("Subscribing to D20 messages...");
			AssetDataPlugin.Subscribe("org.lordashes.plugins.d20", (Action<DatumChange>)RemoteQuery.ReceiveRemoteQueryResult);
		}
		catch (Exception ex)
		{
			LoggingPlugin.LogError("Problem subscribing to D20 messages...");
			LoggingPlugin.LogError(ex.ToString());
			SystemMessage.DisplayInfoText("Subscription Error:\r\nUnable To Subscribing To D20 Messages", 2.5f, 0f, (Action)null);
		}
		try
		{
			characters.LoadCharacters();
		}
		catch (Exception ex2)
		{
			LoggingPlugin.LogError("Problem processing character sheets...");
			LoggingPlugin.LogError(ex2.ToString());
			SystemMessage.DisplayInfoText("Character Sheet Error:\r\nUnable To Process Character Sheets", 2.5f, 0f, (Action)null);
		}
		try
		{
			Scripts.LoadScripts();
		}
		catch (Exception ex3)
		{
			LoggingPlugin.LogError("Problem processing actor's scripts...");
			LoggingPlugin.LogError(ex3.ToString());
			SystemMessage.DisplayInfoText("Actor Scripts Error:\r\nUnable To Process Actor's Scripts", 2.5f, 0f, (Action)null);
		}
		try
		{
			LoadProjectiles();
		}
		catch (Exception ex4)
		{
			LoggingPlugin.LogError("Problem processingprojectiles...");
			LoggingPlugin.LogError(ex4.ToString());
			SystemMessage.DisplayInfoText("Projectiles Error:\r\nUnable To Process Projectiles", 2.5f, 0f, (Action)null);
		}
		if ((int)LoggingPlugin.GetLogLevel() >= 4)
		{
			((MonoBehaviour)this).StartCoroutine(WarnAboutLogLevel());
		}
		Utility.PostOnMainPage((BaseUnityPlugin)(object)this);
	}

	private void Update()
	{
		if (((KeyboardShortcut)(ref toggleMenu)).IsUp())
		{
			menuEditOpen = !menuEditOpen;
			LoggingPlugin.LogDebug("Toggle UI Edit Menu Open to " + menuEditOpen);
			GameInputEnabled(!menuEditOpen);
		}
		if (((KeyboardShortcut)(ref toggleTargetPanel)).IsUp() && targetsCollection.targetsCollecting > 0)
		{
			menuTargetPanelOpen = !menuTargetPanelOpen;
			LoggingPlugin.LogDebug("Toggle Target Panel Menu Open to " + menuTargetPanelOpen);
			GameInputEnabled(!menuTargetPanelOpen);
		}
		if (((KeyboardShortcut)(ref toggleReload)).IsUp())
		{
			LoggingPlugin.LogDebug("Reloading Character Sheets And Message Scripts");
			SystemMessage.DisplayInfoText("Reloading Character Sheets And Message Scripts", 2.5f, 0f, (Action)null);
			DeepMenusPlugin.RemoveMenuBranch("");
			characters.LoadCharacters(reload: true);
			Scripts.scripts.Clear();
			Scripts.LoadScripts();
		}
	}

	private void OnGUI()
	{
		//IL_005f: 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)
		if (menuEditOpen)
		{
			ShowEditUI();
		}
		if (menuTargetPanelOpen)
		{
			ShowTargetPanelUI();
		}
		if (targetsCollection.targetsCollecting > 0)
		{
			ShowTargetCollection();
		}
		if (Scripts.waitingOnRemoteAction)
		{
			GUI.Label(new Rect(200f, 5f, (float)(Screen.width - 60), 30f), "Waiting On Response...");
		}
		if (RemoteQuery.hold != null && GUI.Button(new Rect((float)(Screen.width - 220), (float)(Screen.height - 30), 210f, 25f), RemoteQuery.hold + " Complete"))
		{
			RemoteQuery.reactionToken.SetResult(result: true);
			RemoteQuery.reactionToken = null;
			RemoteQuery.hold = null;
		}
	}

	public static void ShowEditUI()
	{
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		//IL_005c: 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_0128: Unknown result type (might be due to invalid IL or missing references)
		//IL_0175: Unknown result type (might be due to invalid IL or missing references)
		//IL_0248: Unknown result type (might be due to invalid IL or missing references)
		//IL_0295: Unknown result type (might be due to invalid IL or missing references)
		CreatureBoardAsset val = null;
		CreaturePresenter.TryGetAsset(LocalClient.SelectedCreatureId, ref val);
		Characters.CharacterSpecs characterSpecs = _self.characters.FindFirst(DiceRoller.StripTrailingInteger(val.Name));
		if (characterSpecs == null)
		{
			return;
		}
		int num = 400;
		int num2 = Screen.width / 2 - num / 2;
		int num3 = 90;
		GUI.DrawTexture(new Rect((float)num2, (float)num3, (float)num, (float)lastMenuSize), (Texture)(object)backdrop, (ScaleMode)0);
		num3 += 10;
		if (GUI.Button(new Rect((float)(num2 + num - 35), (float)num3, 25f, 20f), "X"))
		{
			menuEditOpen = false;
			GameInputEnabled(!menuEditOpen);
			SaveUserSettings(characterSpecs);
		}
		num3 += 10;
		for (int i = 0; i < characterSpecs.specs.Count; i++)
		{
			if (characterSpecs.specs[i].Extra("edit") != null && characterSpecs.specs[i].Extra("toggle") != null)
			{
				GUI.Label(new Rect((float)(num2 + 10), (float)num3, (float)(num / 2 - 20), 25f), characterSpecs.specs[i].Extra("edit"), labelUI);
				characterSpecs.specs[i].formula = (GUI.Toggle(new Rect((float)(num2 + num / 2 + 10), (float)num3, (float)(num / 2 - 20), 25f), (characterSpecs.specs[i].formula == "1") ? true : false, "") ? "1" : "0");
				num3 += 30;
			}
		}
		for (int j = 0; j < characterSpecs.specs.Count; j++)
		{
			if (characterSpecs.specs[j].Extra("edit") != null && characterSpecs.specs[j].Extra("toggle") == null)
			{
				GUI.Label(new Rect((float)(num2 + 10), (float)num3, (float)(num / 2 - 20), 25f), characterSpecs.specs[j].Extra("edit"), labelUI);
				characterSpecs.specs[j].formula = GUI.TextField(new Rect((float)(num2 + num / 2 + 10), (float)num3, (float)(num / 2 - 20), 25f), characterSpecs.specs[j].formula);
				num3 += 30;
			}
		}
		lastMenuSize = num3 - 60;
	}

	public static void ShowTargetPanelUI()
	{
		//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
		//IL_0215: 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_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0041: Unknown result type (might be due to invalid IL or missing references)
		//IL_0258: Unknown result type (might be due to invalid IL or missing references)
		//IL_0303: 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_0097: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
		//IL_010d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0112: 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_013e: Unknown result type (might be due to invalid IL or missing references)
		if (targets == null || targets.Count == 0)
		{
			LoggingPlugin.LogDebug("Generating Target List");
			CreatureBoardAsset val = null;
			CreaturePresenter.TryGetAsset(LocalClient.SelectedCreatureId, ref val);
			foreach (CreatureBoardAsset item in (IEnumerable<CreatureBoardAsset>)CreaturePresenter.GetTempReadOnlyViewOfAllCreatureAssets())
			{
				if (!item.IsExplicitlyHidden)
				{
					int distance = (int)Math.Round(5f * Vector3.Distance(((Component)((MovableBoardAsset)item).Rotator).transform.position, ((Component)((MovableBoardAsset)val).Rotator).transform.position));
					string[] obj = new string[10] { "Added ", item.Name, " (", null, null, null, null, null, null, null };
					CreatureGuid creatureId = item.CreatureId;
					obj[3] = ((object)(CreatureGuid)(ref creatureId)).ToString();
					obj[4] = ") at distance ";
					obj[5] = distance.ToString();
					obj[6] = " from ";
					Vector3 position = ((Component)((MovableBoardAsset)val).Rotator).transform.position;
					obj[7] = ((object)(Vector3)(ref position)).ToString();
					obj[8] = " To ";
					position = ((Component)((MovableBoardAsset)item).Rotator).transform.position;
					obj[9] = ((object)(Vector3)(ref position)).ToString();
					LoggingPlugin.LogDebug(string.Concat(obj));
					targets.Add(new AssetTarget
					{
						asset = item,
						distance = distance,
						selected = false
					});
				}
			}
			targets.Sort((AssetTarget a, AssetTarget b) => a.distance.CompareTo(b.distance));
		}
		int num = 200;
		int num2 = Screen.width / 2 - num / 2;
		int num3 = 90;
		GUI.DrawTexture(new Rect((float)num2, (float)num3, (float)num, (float)lastMenuSize), (Texture)(object)backdrop, (ScaleMode)0);
		num3 += 10;
		if (GUI.Button(new Rect((float)(num2 + num - 35), (float)num3, 25f, 20f), "X"))
		{
			menuTargetPanelOpen = false;
			GameInputEnabled(setting: true);
		}
		num3 += 30;
		for (int i = 0; i < targets.Count; i++)
		{
			if (GUI.Button(new Rect((float)(num2 + 10), (float)num3, (float)(num - 20), 25f), targets[i].asset.Name + " At " + targets[i].distance + "'"))
			{
				targetsCollection.targetsCollected.Add(targets[i].asset);
			}
			num3 += 30;
		}
		num3 += 10;
		if (GUI.Button(new Rect((float)(num2 + 10), (float)num3, (float)(num - 20), 25f), "Apply Selection"))
		{
			menuTargetPanelOpen = false;
			GameInputEnabled(setting: true);
			PatchCallCameraClick.ProcessSelection();
		}
		lastMenuSize = num3 - 40;
	}

	private void ShowTargetCollection()
	{
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		GUI.Label(new Rect(200f, 5f, (float)(Screen.width - 60), 30f), "Selecting Targets (" + targetsCollection.targetsCollected.Count + " of " + ((targetsCollection.targetsCollecting != int.MaxValue) ? targetsCollection.targetsCollecting.ToString() : "Unlimited") + "): " + string.Join(", ", targetsCollection.targetsCollected.Select((CreatureBoardAsset c) => c.Name)));
	}

	private void LoadProjectiles()
	{
		string[] array = File.Catalog(false);
		foreach (string text in array)
		{
			if (text.ToUpper().EndsWith(".PROJECTILE"))
			{
				Projectile val = JsonConvert.DeserializeObject<Projectile>(File.ReadAllText(text, (CacheType)999));
				projectiles.Add(val.name, val);
				LoggingPlugin.LogDebug("Loaded Projectile " + val.name);
			}
		}
	}

	public static void GameInputEnabled(bool setting)
	{
		//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ba: Expected O, but got Unknown
		if (gameInputInstance == null || gameInputDisable == null || gameInputEnable == null)
		{
			try
			{
				gameInputInstance = null;
				gameInputDisable = null;
				gameInputEnable = null;
				ControllerManager val = default(ControllerManager);
				SimpleSingletonBehaviour<ControllerManager>.TryGetInstance(ref val);
				if ((Object)(object)val != (Object)null)
				{
					LoggingPlugin.LogTrace("ControllerManager = " + (object)val);
					gameInputInstance = (GameInput)(from f in typeof(ControllerManager).GetRuntimeFields()
						where f.Name == "_gameInput"
						select f).FirstOrDefault().GetValue(val);
					gameInputDisable = (from m in typeof(GameInput).GetMethods()
						where m.Name == "Disable"
						select m).ElementAt(0);
					gameInputEnable = (from m in typeof(GameInput).GetMethods()
						where m.Name == "Enable"
						select m).ElementAt(0);
					LoggingPlugin.LogDebug("Successfully Obtained References To Game Input");
				}
				else
				{
					LoggingPlugin.LogWarning("Unable to obtain ControllerManager instance");
				}
			}
			catch
			{
				LoggingPlugin.LogWarning("Unable To Get Game Input Reference Or Reference To One Of Its Methods");
			}
		}
		if (setting)
		{
			LoggingPlugin.LogDebug("Enabling Game Input");
			gameInputEnable.Invoke(gameInputInstance, new object[0]);
		}
		else
		{
			LoggingPlugin.LogDebug("Disabling Game Input");
			gameInputDisable.Invoke(gameInputInstance, new object[0]);
		}
	}

	public static void LoadUserSettings(Characters.CharacterSpecs sheet)
	{
		LoggingPlugin.LogDebug("Starting LoadUserSettings...");
		string[] array = File.Find("org.lordashes.plugins.d20.settings." + sheet.name + ".json", (CacheType)1);
		if (array.Length > 1)
		{
			LoggingPlugin.LogDebug("Ignoiring Setting Backup For Character '" + sheet.name + "'");
		}
		else if (array.Length == 1)
		{
			LoggingPlugin.LogDebug("Loading Setting From '" + array[0] + "'");
		}
		else
		{
			LoggingPlugin.LogDebug("No Setting To Load For '" + sheet.name + "'");
		}
		if (array.Length != 0)
		{
			LoggingPlugin.LogDebug("Loading Setting From '" + array[0] + "'");
			try
			{
				string text = File.ReadAllText(array[0], (CacheType)999);
				List<Characters.Spec> list = JsonConvert.DeserializeObject<List<Characters.Spec>>(text);
				for (int i = 0; i < list.Count; i++)
				{
					LoggingPlugin.LogDebug("Processing Setting " + (i + 1) + " of " + list.Count + ": " + list[i].name + " => " + list[i].formula);
					Characters.Spec spec = sheet.FindFirst("name==\"" + list[i].name + "\"");
					if (spec != null)
					{
						sheet.specs.Remove(spec);
					}
					sheet.specs.Add(list[i]);
				}
			}
			catch (Exception ex)
			{
				LoggingPlugin.LogDebug("Unable To Process File '" + array[0] + ". Using defaults. Reason: " + ex.Message);
			}
		}
		else
		{
			LoggingPlugin.LogDebug("No Setting For Character '" + sheet.name + "'. Using defaults.");
		}
		LoggingPlugin.LogDebug("Ended LoadUserSettings...");
	}

	public static void SaveUserSettings(Characters.CharacterSpecs sheet)
	{
		LoggingPlugin.LogDebug("Starting SaveUserSettings...");
		string[] array = File.Find("org.lordashes.plugins.d20.settings." + sheet.name + ".json", (CacheType)999);
		if (array.Length == 0)
		{
			if (!File.Exists(pluginFolder + "/CustomData/*"))
			{
				Directory.CreateDirectory(pluginFolder + "/CustomData/");
			}
			if (!File.Exists(pluginFolder + "/CustomData/config*"))
			{
				Directory.CreateDirectory(pluginFolder + "/CustomData/config");
			}
			array = new string[1] { pluginFolder + "/CustomData/config/org.lordashes.plugins.d20.settings." + sheet.name + ".json" };
		}
		LoggingPlugin.LogDebug("Saving Setting To '" + array[0] + "'");
		List<Characters.Spec> list = new List<Characters.Spec>();
		for (int i = 0; i < sheet.specs.Count; i++)
		{
			if (sheet.specs[i].Extra("edit") != null)
			{
				list.Add(sheet.specs[i]);
			}
		}
		File.WriteAllText(array[0], JsonConvert.SerializeObject((object)list, (Formatting)1), (CacheType)999);
		LoggingPlugin.LogDebug("Ended SaveUserSettings...");
	}

	[IteratorStateMachine(typeof(<WarnAboutLogLevel>d__65))]
	private IEnumerator WarnAboutLogLevel()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <WarnAboutLogLevel>d__65(0)
		{
			<>4__this = this
		};
	}
}