Decompiled source of CustomQuests v1.1.0

Yavamar.CustomQuests.dll

Decompiled a day ago
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Mirror;
using Newtonsoft.Json;
using UnityEngine;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: IgnoresAccessChecksTo("Mirror")]
[assembly: IgnoresAccessChecksTo("UnityEngine.UI")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Yavamar.CustomQuests")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.1.0.0")]
[assembly: AssemblyInformationalVersion("1.1.0+a0f06d406a8c8bacc1b83ea4f30e26850070e43d")]
[assembly: AssemblyProduct("CustomQuests")]
[assembly: AssemblyTitle("Yavamar.CustomQuests")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace CustomQuest
{
	[HarmonyPatch(typeof(DialogTrigger), "BeginDialog")]
	public static class DialogTriggerPatch
	{
		[HarmonyPrefix]
		private static void BeginDialogPatch(ref ScriptableDialogData _dialogData)
		{
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Invalid comparison between Unknown and I4
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Expected O, but got Unknown
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Expected O, but got Unknown
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Expected O, but got Unknown
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Expected O, but got Unknown
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Expected O, but got Unknown
			if (Plugin.questGiver != null && Plugin.questGiver.ContainsKey(_dialogData._nameTag))
			{
				ScriptableDialogData val = _dialogData;
				if (val._scriptableQuests == null)
				{
					val._scriptableQuests = Array.Empty<ScriptableQuest>();
				}
				List<ScriptableQuest> list = _dialogData._scriptableQuests.ToList();
				foreach (string item in Plugin.questGiver[_dialogData._nameTag])
				{
					if (!_dialogData._scriptableQuests.Contains(Plugin.gameManager._cachedScriptableQuests[item]))
					{
						list.Add(Plugin.gameManager._cachedScriptableQuests[item]);
						Plugin.Logger.LogInfo((object)(item + ": Added to " + _dialogData._nameTag + "'s ScriptableDialogData"));
					}
				}
				_dialogData._scriptableQuests = list.ToArray();
			}
			if (_dialogData._scriptableQuests == null || _dialogData._scriptableQuests.Length == 0)
			{
				return;
			}
			bool flag = false;
			DialogBranch[] dialogBranches = _dialogData._dialogBranches;
			foreach (DialogBranch val2 in dialogBranches)
			{
				if ((int)val2.dialogs.First()._dialogUI == 1)
				{
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				_dialogData._dialogBranches.First().dialogs.Last()._dialogSelections = _dialogData._dialogBranches.First().dialogs.Last()._dialogSelections.Append(new DialogSelection
				{
					_selectionCaption = "Got Quests?",
					_selectionIcon = Plugin._cachedSprite["_lexiconIco02"],
					_setDialogIndex = _dialogData._dialogBranches.Length
				}).ToArray();
				ScriptableDialogData obj = _dialogData;
				DialogBranch[] dialogBranches2 = _dialogData._dialogBranches;
				DialogBranch val3 = new DialogBranch();
				Dialog[] array = new Dialog[1];
				Dialog val4 = new Dialog();
				val4._dialogKey = _dialogData._nameTag + "Quest";
				val4._dialogUI = (DialogUIPrompt)1;
				val4._altInputs = new string[1] { "Here are my quests." };
				val4._dialogSelections = (DialogSelection[])(object)new DialogSelection[2]
				{
					new DialogSelection
					{
						_selectionCaption = "See ya!",
						_setDialogIndex = -1
					},
					new DialogSelection
					{
						_selectionCaption = "Something else...",
						_setDialogIndex = 0
					}
				};
				array[0] = val4;
				val3.dialogs = (Dialog[])(object)array;
				obj._dialogBranches = dialogBranches2.Append(val3).ToArray();
				_dialogData._questAcceptResponses = new string[1] { "Quest Accepted." };
				_dialogData._questCompleteResponses = new string[1] { "Quest Complete!" };
			}
		}
	}
	public static class DictionaryExt
	{
		public static IEnumerable<T> PartialMatch<T>(this Dictionary<string, T> dictionary, string partialKey)
		{
			IEnumerable<string> enumerable = dictionary.Keys.Where((string currentKey) => currentKey.Contains(partialKey));
			List<T> list = new List<T>();
			foreach (string item in enumerable)
			{
				list.Add(dictionary[item]);
			}
			return list;
		}
	}
	[HarmonyPatch(typeof(GameManager), "Cache_ScriptableAssets")]
	public static class GameManagerPatch
	{
		[HarmonyPostfix]
		private static void Cache_ScriptableAssetsPatch()
		{
			Plugin.gameManager = GameManager._current;
			Sprite[] array = Resources.LoadAll<Sprite>("_GRAPHIC/_UI/");
			for (int i = 0; i < array.Length; i++)
			{
				Plugin._cachedSprite.Add(((Object)array[i]).name, array[i]);
			}
			foreach (string jsonFilePath in Plugin.jsonFilePaths)
			{
				ParseJsonQuest(jsonFilePath);
			}
			Plugin.jsonFilePaths.Clear();
		}

		public static void ParseJsonQuest(string filePath)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Expected O, but got Unknown
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Expected O, but got Unknown
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: 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_0167: Expected O, but got Unknown
			ParsedQuest parsedQuest = new JsonSerializer().Deserialize<ParsedQuest>((JsonReader)new JsonTextReader((TextReader)new StreamReader(filePath)));
			ScriptableQuest val = ScriptableObject.CreateInstance<ScriptableQuest>();
			val._questName = parsedQuest._questName;
			val._questDescription = parsedQuest._questDescription;
			val._questCompleteReturnMessage = parsedQuest._questCompleteReturnMessage;
			val._questLevel = parsedQuest._questLevel;
			val._requireNoviceClass = parsedQuest._requireNoviceClass;
			val._autoFinishQuest = parsedQuest._autoFinishQuest;
			val._scenePath = parsedQuest._scenePath;
			if (parsedQuest._questExperienceReward != 0)
			{
				val._questExperiencePercentage = (float)parsedQuest._questExperienceReward / GameManager._current._statLogics._experienceCurve.Evaluate((float)val._questLevel);
				int num = (int)((float)(int)GameManager._current._statLogics._experienceCurve.Evaluate((float)val._questLevel) * val._questExperiencePercentage);
				int num2 = parsedQuest._questExperienceReward - num;
				val._questExperiencePercentage = (float)(parsedQuest._questExperienceReward + num2) / GameManager._current._statLogics._experienceCurve.Evaluate((float)val._questLevel);
			}
			else
			{
				val._questExperiencePercentage = parsedQuest._questExperiencePercentage;
			}
			val._questCurrencyReward = parsedQuest._questCurrencyReward;
			val._preQuestRequirements = Array.Empty<ScriptableQuest>();
			val._questObjectiveItem = new QuestItemReward();
			val._questItemRewards = Array.Empty<QuestItemReward>();
			val._questObjective = new QuestObjective
			{
				_questCreepRequirements = Array.Empty<QuestCreepRequirement>(),
				_questItemRequirements = Array.Empty<QuestItemRequirement>(),
				_questTriggerRequirements = Array.Empty<QuestTriggerRequirement>()
			};
			Plugin.gameManager._cachedScriptableQuests.Add(val._questName, val);
			Plugin.Logger.LogInfo((object)(val._questName + ": Cached."));
			Plugin.parsedQuests.Add(parsedQuest);
		}
	}
	[HarmonyPatch(typeof(MapInstance), "Start")]
	internal class MapInstancePatch
	{
		public static void Postfix(MapInstance __instance)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Expected O, but got Unknown
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: 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_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_027b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02af: Unknown result type (might be due to invalid IL or missing references)
			foreach (ParsedQuestTrigger parsedQuestTrigger in Plugin.parsedQuestTriggers)
			{
				if (!(parsedQuestTrigger._mapInstance == __instance._mapName))
				{
					continue;
				}
				Plugin.Logger.LogMessage((object)("Loading QuestTrigger " + parsedQuestTrigger._questTriggerTag));
				GameObject[] array = Resources.LoadAll<GameObject>("_prefab/_entity/_trigger/");
				GameObject val = new GameObject();
				GameObject[] array2 = array;
				foreach (GameObject val2 in array2)
				{
					if ((Object)(object)val2.GetComponent<QuestTrigger>() != (Object)null)
					{
						val = val2;
						break;
					}
				}
				Plugin.Logger.LogInfo((object)"Registering Quest Trigger prefab");
				val.GetComponent<QuestTrigger>()._visualContainer = null;
				val.GetComponent<QuestTrigger>()._questTriggerAnimator = null;
				val.GetComponent<QuestTrigger>()._questTriggerParticles = null;
				val.GetComponent<QuestTrigger>()._aSrcOnInteract = null;
				val.GetComponent<QuestTrigger>()._disableVisualIfNotOnQuest = true;
				NetworkClient.RegisterPrefab(val);
				Plugin.Logger.LogInfo((object)"Quest Trigger Prefab Registered");
				GameObject val3 = Object.Instantiate<GameObject>(val);
				val3.transform.SetPositionAndRotation(parsedQuestTrigger.position, Quaternion.identity);
				QuestTrigger component = val3.GetComponent<QuestTrigger>();
				component._scriptQuest = parsedQuestTrigger._scriptQuest;
				component._mapInstance = __instance;
				component._questTriggerTag = parsedQuestTrigger._questTriggerTag;
				component._interactTrigger = parsedQuestTrigger._interactTrigger;
				component._completedRequirements = parsedQuestTrigger._completedRequirements;
				component._questTriggerOnlyOnce = parsedQuestTrigger._questTriggerOnlyOnce;
				component._netTriggerToInvoke = null;
				Enum.TryParse<QuestTriggerCondition>(parsedQuestTrigger._netTriggerType, out component._netTriggerType);
				component._triggerMessage = parsedQuestTrigger._triggerMessage;
				component._patternInstanceManager = null;
				Enum.TryParse<ZoneDifficulty>(parsedQuestTrigger._difficultyRequirement, out component._difficultyRequirement);
				component._arenaSweepQuest = parsedQuestTrigger._arenaSweepQuest;
				switch (parsedQuestTrigger._triggerCollider.type)
				{
				case "Sphere":
				{
					component._triggerCollider = (Collider)(object)((Component)component).gameObject.AddComponent<SphereCollider>();
					Collider triggerCollider7 = component._triggerCollider;
					((SphereCollider)((triggerCollider7 is SphereCollider) ? triggerCollider7 : null)).center = parsedQuestTrigger._triggerCollider.center;
					Collider triggerCollider8 = component._triggerCollider;
					((SphereCollider)((triggerCollider8 is SphereCollider) ? triggerCollider8 : null)).radius = parsedQuestTrigger._triggerCollider.radius;
					break;
				}
				case "Box":
				{
					component._triggerCollider = (Collider)(object)((Component)component).gameObject.AddComponent<BoxCollider>();
					Collider triggerCollider5 = component._triggerCollider;
					((BoxCollider)((triggerCollider5 is BoxCollider) ? triggerCollider5 : null)).center = parsedQuestTrigger._triggerCollider.center;
					Collider triggerCollider6 = component._triggerCollider;
					((BoxCollider)((triggerCollider6 is BoxCollider) ? triggerCollider6 : null)).size = parsedQuestTrigger._triggerCollider.size;
					break;
				}
				case "Capsule":
				{
					component._triggerCollider = (Collider)(object)((Component)component).gameObject.AddComponent<CapsuleCollider>();
					Collider triggerCollider = component._triggerCollider;
					((CapsuleCollider)((triggerCollider is CapsuleCollider) ? triggerCollider : null)).center = parsedQuestTrigger._triggerCollider.center;
					Collider triggerCollider2 = component._triggerCollider;
					((CapsuleCollider)((triggerCollider2 is CapsuleCollider) ? triggerCollider2 : null)).radius = parsedQuestTrigger._triggerCollider.radius;
					Collider triggerCollider3 = component._triggerCollider;
					((CapsuleCollider)((triggerCollider3 is CapsuleCollider) ? triggerCollider3 : null)).height = parsedQuestTrigger._triggerCollider.height;
					Collider triggerCollider4 = component._triggerCollider;
					((CapsuleCollider)((triggerCollider4 is CapsuleCollider) ? triggerCollider4 : null)).radius = parsedQuestTrigger._triggerCollider.direction;
					break;
				}
				}
				component._triggerCollider.isTrigger = true;
				component._triggerCollider.material = null;
				((Object)val3).name = "_QuestTrigger(" + component._scriptQuest._questName + ", " + component._questTriggerTag + ")";
				SceneManager.MoveGameObjectToScene(val3, __instance._loadedScene);
				NetworkServer.Spawn(val3, (NetworkConnection)null);
				Plugin.Logger.LogMessage((object)"Quest Trigger created!");
			}
		}
	}
	public class ParsedQuest
	{
		public string questGiver { get; set; }

		public string _questName { get; set; }

		public string _questType { get; set; }

		public string _questSubType { get; set; }

		public string _questIco { get; set; }

		public string _questDescription { get; set; }

		public string _questCompleteReturnMessage { get; set; }

		public int _questLevel { get; set; }

		public string _raceRequirement { get; set; }

		public string _baseClassRequirement { get; set; }

		public string _skillToHide { get; set; }

		public bool _requireNoviceClass { get; set; }

		public bool _autoFinishQuest { get; set; }

		public string[] _preQuestRequirements { get; set; }

		public ParsedQuestItemReward _questObjectiveItem { get; set; }

		public string _scenePath { get; set; }

		public Dictionary<string, int> _questItemRequirements { get; set; }

		public Dictionary<string, int> _questCreepRequirements { get; set; }

		public QuestTriggerRequirement[] _questTriggerRequirements { get; set; }

		public List<ParsedQuestTrigger> questTriggers { get; set; }

		public float _questExperiencePercentage { get; set; }

		public int _questExperienceReward { get; set; }

		public int _questCurrencyReward { get; set; }

		public ParsedQuestItemReward[] _questItemRewards { get; set; }
	}
	public class ParsedQuestItemReward
	{
		public string _scriptItem { get; set; }

		public int _scriptableStatModifier { get; set; }

		public string scriptableStatModifierName { get; set; }

		public int _itemQuantity { get; set; }
	}
	public class ParsedQuestTrigger
	{
		public string _questTriggerTag { get; set; }

		public string _mapInstance { get; set; }

		public Vector3 position { get; set; }

		public string _difficultyRequirement { get; set; }

		public bool _interactTrigger { get; set; }

		public bool _completedRequirements { get; set; }

		public bool _questTriggerOnlyOnce { get; set; }

		public NetTrigger _netTriggerToInvoke { get; set; }

		public string _netTriggerType { get; set; }

		public TriggerMessage _triggerMessage { get; set; }

		public bool _arenaSweepQuest { get; set; }

		public ParsedCollider _triggerCollider { get; set; }

		public ScriptableQuest _scriptQuest { get; set; }
	}
	public class ParsedCollider
	{
		public string type { get; set; }

		public Vector3 center { get; set; }

		public float radius { get; set; }

		public Vector3 size { get; set; }

		public float height { get; set; }

		public int direction { get; set; }
	}
	[HarmonyPatch(typeof(PlayerQuesting), "OnStartAuthority")]
	public static class PlayerQuestingPatch
	{
		[HarmonyPrefix]
		private static void Prefix()
		{
			if (Plugin.parsedQuests == null)
			{
				return;
			}
			foreach (ParsedQuest parsedQuest in Plugin.parsedQuests)
			{
				if (Plugin.questGiver.ContainsKey(parsedQuest.questGiver))
				{
					Plugin.questGiver[parsedQuest.questGiver].Add(parsedQuest._questName);
				}
				else
				{
					Plugin.questGiver.Add(parsedQuest.questGiver, new List<string>(1) { parsedQuest._questName });
				}
				LoadQuestDetails(parsedQuest);
			}
			Plugin.parsedQuests.Clear();
		}

		public static void LoadQuestDetails(ParsedQuest parsedQuest)
		{
			//IL_0519: Unknown result type (might be due to invalid IL or missing references)
			//IL_0520: Expected O, but got Unknown
			//IL_036c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0371: Unknown result type (might be due to invalid IL or missing references)
			//IL_0379: Unknown result type (might be due to invalid IL or missing references)
			//IL_0386: Expected O, but got Unknown
			//IL_042f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0434: Unknown result type (might be due to invalid IL or missing references)
			//IL_043c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0449: Expected O, but got Unknown
			//IL_0602: Unknown result type (might be due to invalid IL or missing references)
			//IL_0609: Expected O, but got Unknown
			GameManager gameManager = Plugin.gameManager;
			gameManager._cachedScriptableQuests.TryGetValue(parsedQuest._questName, out var value);
			Dictionary<string, ScriptableStatModifier> dictionary = new Dictionary<string, ScriptableStatModifier>();
			int value2;
			foreach (KeyValuePair<int, ScriptableStatModifier> cachedScriptableStatModifier in gameManager._cachedScriptableStatModifiers)
			{
				cachedScriptableStatModifier.Deconstruct(out value2, out var value3);
				ScriptableStatModifier val = value3;
				dictionary.Add(val._modifierTag, val);
			}
			Plugin.Logger.LogInfo((object)(value._questName + ": Setting Quest Type."));
			if (!Enum.TryParse<QuestType>(parsedQuest._questType, out value._questType))
			{
				Plugin.Logger.LogWarning((object)("_questType " + parsedQuest._questType + " is not valid."));
			}
			Plugin.Logger.LogInfo((object)(value._questName + ": Setting Quest SubType."));
			if (!Enum.TryParse<QuestSubType>(parsedQuest._questSubType, out value._questSubType))
			{
				Plugin.Logger.LogWarning((object)("_questSubType " + parsedQuest._questSubType + " is not valid."));
			}
			Plugin.Logger.LogInfo((object)(value._questName + ": Setting Quest Icon."));
			value._questIco = Plugin._cachedSprite[parsedQuest._questIco];
			if (parsedQuest._skillToHide != null)
			{
				Plugin.Logger.LogInfo((object)(value._questName + ": Setting Skill To Hide."));
				if (!gameManager._cachedScriptableSkills.TryGetValue(parsedQuest._skillToHide, out value._skillToHide))
				{
					Plugin.Logger.LogWarning((object)(value._questName + ": Skill " + parsedQuest._skillToHide + " not found!"));
				}
			}
			if (parsedQuest._raceRequirement != null)
			{
				Plugin.Logger.LogInfo((object)(value._questName + ": Setting Race Requirement."));
				if (!gameManager._cachedScriptableRaces.TryGetValue(parsedQuest._raceRequirement, out value._raceRequirement))
				{
					Plugin.Logger.LogWarning((object)(value._questName + ": Race " + parsedQuest._raceRequirement + " not found!"));
				}
			}
			if (parsedQuest._baseClassRequirement != null)
			{
				Plugin.Logger.LogInfo((object)(value._questName + ": Setting Base Class Requirement."));
				if (!gameManager._cachedScriptablePlayerClasses.TryGetValue(parsedQuest._baseClassRequirement, out value._baseClassRequirement))
				{
					Plugin.Logger.LogWarning((object)(value._questName + ": Class " + parsedQuest._baseClassRequirement + " not found!"));
				}
			}
			if (parsedQuest._preQuestRequirements != null)
			{
				Plugin.Logger.LogInfo((object)(value._questName + ": Setting Pre-Quest Requirements."));
				List<ScriptableQuest> list = new List<ScriptableQuest>();
				string[] preQuestRequirements = parsedQuest._preQuestRequirements;
				foreach (string text in preQuestRequirements)
				{
					if (gameManager._cachedScriptableQuests.TryGetValue(text, out var value4))
					{
						list.Add(value4);
					}
					else
					{
						Plugin.Logger.LogWarning((object)(value._questName + ": Quest " + text + " not found!"));
					}
				}
				value._preQuestRequirements = list.ToArray();
			}
			string key;
			if (parsedQuest._questCreepRequirements != null)
			{
				Plugin.Logger.LogInfo((object)(value._questName + ": Setting Quest Creep Requirements."));
				List<QuestCreepRequirement> list2 = new List<QuestCreepRequirement>();
				foreach (KeyValuePair<string, int> questCreepRequirement in parsedQuest._questCreepRequirements)
				{
					questCreepRequirement.Deconstruct(out key, out value2);
					string text2 = key;
					int creepsKilled = value2;
					if (!gameManager._cachedScriptableCreeps.TryGetValue(text2, out var value5))
					{
						value5 = gameManager._cachedScriptableCreeps.PartialMatch(text2).First();
					}
					list2.Add(new QuestCreepRequirement
					{
						_questCreep = value5,
						_creepsKilled = creepsKilled
					});
				}
				value._questObjective._questCreepRequirements = list2.ToArray();
			}
			if (parsedQuest._questItemRequirements != null)
			{
				Plugin.Logger.LogInfo((object)(value._questName + ": Setting Quest Item Requirements."));
				List<QuestItemRequirement> list3 = new List<QuestItemRequirement>();
				foreach (KeyValuePair<string, int> questItemRequirement in parsedQuest._questItemRequirements)
				{
					questItemRequirement.Deconstruct(out key, out value2);
					string text3 = key;
					int itemsNeeded = value2;
					if (!gameManager._cachedScriptableItems.TryGetValue(text3, out var value6))
					{
						value6 = gameManager._cachedScriptableItems.PartialMatch(text3).First();
					}
					list3.Add(new QuestItemRequirement
					{
						_questItem = value6,
						_itemsNeeded = itemsNeeded
					});
				}
				value._questObjective._questItemRequirements = list3.ToArray();
			}
			if (parsedQuest._questTriggerRequirements != null)
			{
				Plugin.Logger.LogInfo((object)(value._questName + ": Setting Quest Trigger Requirements."));
				value._questObjective._questTriggerRequirements = parsedQuest._questTriggerRequirements;
			}
			if (parsedQuest.questTriggers != null)
			{
				foreach (ParsedQuestTrigger questTrigger in parsedQuest.questTriggers)
				{
					questTrigger._scriptQuest = value;
					Plugin.parsedQuestTriggers.Add(questTrigger);
				}
			}
			if (parsedQuest._questObjectiveItem != null)
			{
				Plugin.Logger.LogInfo((object)(value._questName + ": Setting Quest Objective Item."));
				QuestItemReward val2 = new QuestItemReward();
				if (!gameManager._cachedScriptableItems.TryGetValue(parsedQuest._questObjectiveItem._scriptItem, out val2._scriptItem))
				{
					val2._scriptItem = gameManager._cachedScriptableItems.PartialMatch(parsedQuest._questObjectiveItem._scriptItem).First();
				}
				gameManager._cachedScriptableStatModifiers.TryGetValue(parsedQuest._questObjectiveItem._scriptableStatModifier, out val2._scriptableStatModifier);
				if (parsedQuest._questObjectiveItem.scriptableStatModifierName != null)
				{
					dictionary.TryGetValue(parsedQuest._questObjectiveItem.scriptableStatModifierName, out val2._scriptableStatModifier);
				}
				val2._itemQuantity = parsedQuest._questObjectiveItem._itemQuantity;
				value._questObjectiveItem = val2;
			}
			if (parsedQuest._questItemRewards == null)
			{
				return;
			}
			Plugin.Logger.LogInfo((object)(value._questName + ": Setting Quest Item Rewards."));
			List<QuestItemReward> list4 = new List<QuestItemReward>();
			ParsedQuestItemReward[] questItemRewards = parsedQuest._questItemRewards;
			foreach (ParsedQuestItemReward parsedQuestItemReward in questItemRewards)
			{
				QuestItemReward val3 = new QuestItemReward();
				if (!gameManager._cachedScriptableItems.TryGetValue(parsedQuestItemReward._scriptItem, out val3._scriptItem))
				{
					val3._scriptItem = gameManager._cachedScriptableItems.PartialMatch(parsedQuestItemReward._scriptItem).First();
				}
				gameManager._cachedScriptableStatModifiers.TryGetValue(parsedQuestItemReward._scriptableStatModifier, out val3._scriptableStatModifier);
				if (parsedQuestItemReward.scriptableStatModifierName != null)
				{
					dictionary.TryGetValue(parsedQuestItemReward.scriptableStatModifierName, out val3._scriptableStatModifier);
				}
				val3._itemQuantity = parsedQuestItemReward._itemQuantity;
				list4.Add(val3);
			}
			value._questItemRewards = list4.ToArray();
		}
	}
	[BepInPlugin("Yavamar.CustomQuests", "CustomQuests", "1.1.0")]
	public class Plugin : BaseUnityPlugin
	{
		internal static ManualLogSource Logger;

		public static GameManager gameManager;

		public static Dictionary<string, Sprite> _cachedSprite = new Dictionary<string, Sprite>();

		public static List<string> jsonFilePaths = new List<string>();

		public static List<ParsedQuest> parsedQuests = new List<ParsedQuest>();

		public static Dictionary<string, List<string>> questGiver = new Dictionary<string, List<string>>();

		public static List<ParsedQuestTrigger> parsedQuestTriggers = new List<ParsedQuestTrigger>();

		private void Awake()
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			Logger = ((BaseUnityPlugin)this).Logger;
			Logger.LogInfo((object)"Plugin Yavamar.CustomQuests is loaded!");
			if (Directory.Exists(Paths.PluginPath))
			{
				FindCustomQuestsFolder(Paths.PluginPath);
			}
			new Harmony("Yavamar.CustomQuests").PatchAll(Assembly.GetExecutingAssembly());
		}

		public static void FindCustomQuestsFolder(string dirPath)
		{
			if (dirPath.ToUpper().EndsWith("CUSTOMQUESTS-FILES"))
			{
				CheckFiles(dirPath);
			}
			string[] directories = Directory.GetDirectories(dirPath);
			string[] array = directories;
			string[] array2 = array;
			foreach (string dirPath2 in array2)
			{
				FindCustomQuestsFolder(dirPath2);
			}
		}

		public static void CheckFiles(string path)
		{
			string[] files = Directory.GetFiles(path);
			foreach (string text in files)
			{
				if (text.ToUpper().EndsWith(".JSON"))
				{
					Logger.LogInfo((object)("Adding " + text + " to list of quest files to be read."));
					jsonFilePaths.Add(text);
				}
			}
			string[] directories = Directory.GetDirectories(path);
			foreach (string path2 in directories)
			{
				CheckFiles(path2);
			}
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "Yavamar.CustomQuests";

		public const string PLUGIN_NAME = "CustomQuests";

		public const string PLUGIN_VERSION = "1.1.0";
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}