using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using SideLoader;
using SideLoader.Model;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("0.0.0.0")]
namespace IronCoin;

[BepInPlugin("com.ehaugw.ironcoin", "Iron Coin", "1.0.0")]
public class IronCoin : BaseUnityPlugin
{
	public const string GUID = "com.ehaugw.ironcoin";

	public const string VERSION = "1.0.0";

	public const string NAME = "Iron Coin";

	public static IronCoin Instance;

	public StatusEffect impendingDoomInstance;

	internal void Awake()
	{
		Instance = this;
		SL.OnPacksLoaded += OnPackLoaded;
	}

	private void OnPackLoaded()
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Expected O, but got Unknown
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		SL_Item val = new SL_Item();
		val.Name = "Iron Coin";
		val.EffectBehaviour = (EditBehaviours)2;
		val.Target_ItemID = 6000070;
		val.New_ItemID = 2502524;
		val.SLPackName = Directory.GetParent(typeof(IronCoin).Assembly.Location).Name.ToString();
		val.SubfolderName = "IronCoin";
		val.Description = "An iron coin, minted with a faceless portrait";
		SL_Item val2 = val;
		((ContentTemplate)val2).ApplyTemplate();
	}
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using HarmonyLib;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("0.0.0.0")]
namespace Proficiencies;

public interface IWeaponProficiencyFromItem
{
	float Apply(Item item);
}
public interface IWeaponProficiencyOnCharacter
{
	void Apply(Character character, float original, ref float result);
}
[BepInPlugin("com.ehaugw.proficiencies", "Proficiencies", "1.0.1")]
public class Proficiencies : BaseUnityPlugin
{
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	public class Item_Description
	{
		[HarmonyPostfix]
		public static void Postfix(Item __instance, ref string __result)
		{
			float weaponProficiency = __instance.GetWeaponProficiency();
			if (weaponProficiency != 0f)
			{
				__result = "Weapon Proficiency: " + weaponProficiency + "\n" + __result;
			}
		}
	}

	public const string GUID = "com.ehaugw.proficiencies";

	public const string VERSION = "1.0.1";

	public const string NAME = "Proficiencies";

	public static List<IWeaponProficiencyOnCharacter> IWeaponProficiencyOnCharacterSources = new List<IWeaponProficiencyOnCharacter>();

	public static List<IWeaponProficiencyFromItem> IWeaponProfiencyFromItemSources = new List<IWeaponProficiencyFromItem>();

	internal void Awake()
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Expected O, but got Unknown
		Harmony val = new Harmony("com.ehaugw.proficiencies");
		val.PatchAll();
	}
}
public static class ProficiencyExtensions
{
	public static float GetWeaponProficiency(this Item item)
	{
		return Proficiencies.IWeaponProfiencyFromItemSources.Select((IWeaponProficiencyFromItem modifier) => modifier.Apply(item)).Sum();
	}

	public static float GetTotalWeaponProficiency(this Character character)
	{
		EquipmentSlotIDs[] array = new EquipmentSlotIDs[6];
		RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		float num = ((IEnumerable<EquipmentSlotIDs>)(object)array).Select(delegate(EquipmentSlotIDs slot)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			Character obj = character;
			float? obj2;
			if (obj == null)
			{
				obj2 = null;
			}
			else
			{
				CharacterInventory inventory = obj.Inventory;
				obj2 = ((inventory == null) ? null : inventory.GetEquippedItem(slot)?.GetWeaponProficiency());
			}
			float? num2 = obj2;
			return num2.GetValueOrDefault();
		}).Sum();
		float result = num;
		foreach (IWeaponProficiencyOnCharacter iWeaponProficiencyOnCharacterSource in Proficiencies.IWeaponProficiencyOnCharacterSources)
		{
			iWeaponProficiencyOnCharacterSource.Apply(character, num, ref result);
		}
		return result;
	}
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Threading.Tasks;
using BepInEx;
using HarmonyLib;
using MapMagic;
using Photon;
using SideLoader;
using TinyHelper;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("0.0.0.0")]
namespace SynchronizedWorldObjects;

[BepInPlugin("com.ehaugw.synchronizedworldobjects", "Synchronized World Objects", "1.0.3")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency("com.ehaugw.tinyhelper", "4.5.0")]
public class SynchronizedWorldObjects : BaseUnityPlugin
{
	public const string GUID = "com.ehaugw.synchronizedworldobjects";

	public const string VERSION = "1.0.3";

	public const string NAME = "Synchronized World Objects";

	internal void Awake()
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Expected O, but got Unknown
		//IL_004d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: Expected O, but got Unknown
		GameObject val = new GameObject("SynchronizedWorldObjectsRPC");
		Object.DontDestroyOnLoad((Object)(object)val);
		val.AddComponent<SynchronizedWorldObjectManager>();
		SynchronizedWorldObjectManager.SyncedWorldObjects = new List<SynchronizedWorldObject>();
		SL.OnPacksLoaded += OnPackLoaded;
		SL.OnSceneLoaded += OnSceneLoaded;
		Harmony val2 = new Harmony("com.ehaugw.synchronizedworldobjects");
		val2.PatchAll();
	}

	private void OnPackLoaded()
	{
	}

	private void OnSceneLoaded()
	{
		SynchronizedWorldObjectManager.OnSceneLoaded();
	}
}
public abstract class SynchronizedWorldObject
{
	public string IdentifierName;

	public string SceneIdentifierName;

	public int RPCListenerID;

	public string Uid;

	public SynchronizedWorldObject(string identifierName, int rpcListenerID)
	{
		IdentifierName = identifierName;
		RPCListenerID = rpcListenerID;
		SynchronizedWorldObjectManager.SyncedWorldObjects.Add(this);
	}

	public virtual bool ShouldBeSpawned()
	{
		return SceneManagerHelper.ActiveSceneName == SceneIdentifierName;
	}

	public abstract bool OnSceneLoaded();

	public abstract bool OnGuestJoined(string guestUID);

	public abstract object SetupClientSide(int rpcListenerID, string instanceUID, int sceneViewID, int recursionCount, string rpcMeta);
}
internal class SynchronizedWorldObjectManager : MonoBehaviour
{
	public static SynchronizedWorldObjectManager Instance;

	public static List<SynchronizedWorldObject> SyncedWorldObjects;

	public static void OnSceneLoaded()
	{
		foreach (SynchronizedWorldObject syncedWorldObject in SyncedWorldObjects)
		{
			syncedWorldObject.OnSceneLoaded();
		}
	}

	internal void Start()
	{
		Instance = this;
		PhotonView val = ((Component)this).gameObject.AddComponent<PhotonView>();
		val.viewID = 951;
		Debug.Log((object)("Registered SynchronizedWorldObjectManager with ViewID " + ((MonoBehaviour)this).photonView.viewID));
	}

	[PunRPC]
	public void SetupClientSide(int rpcListenerID, string instanceUID, int sceneViewID, int recursionCount, string rpcMeta)
	{
		foreach (SynchronizedWorldObject syncedWorldObject in SyncedWorldObjects)
		{
			syncedWorldObject.SetupClientSide(rpcListenerID, instanceUID, sceneViewID, recursionCount, rpcMeta);
		}
	}
}
public class SynchronizedDeployable : SynchronizedEquipment
{
	public SynchronizedDeployable(int itemID)
		: base(itemID)
	{
	}

	public override object SetupClientSide(int rpcListenerID, string instanceUID, int sceneViewID, int recursionCount, string rpcMeta)
	{
		return null;
	}

	public override Item SetupServerSide()
	{
		Item val = base.SetupServerSide();
		val.IsPickable = false;
		val.HasPhysicsWhenWorld = false;
		Deployable component = ((Component)val).GetComponent<Deployable>();
		component.StartDeployAnimation();
		Dropable component2 = ((Component)val).GetComponent<Dropable>();
		if (Object.op_Implicit((Object)(object)component2))
		{
			component2.GenerateContents();
		}
		FueledContainer component3 = ((Component)val).GetComponent<FueledContainer>();
		if (Object.op_Implicit((Object)(object)component3))
		{
			component3.TryKindle = true;
		}
		return val;
	}
}
public class SynchronizedEquipment : SynchronizedWorldObject
{
	public Vector3 Position;

	public Vector3 Rotation;

	public Vector3 Scale;

	public int ItemID;

	public bool IsPickable = false;

	public SynchronizedEquipment(int itemID)
		: base("-1", -1)
	{
		ItemID = itemID;
	}

	public void AddToScene(string scene, Vector3 position, Vector3 rotation, Vector3 scale)
	{
		//IL_0009: Unknown result type (might be due to invalid IL or missing references)
		//IL_000a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: 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)
		SceneIdentifierName = scene;
		Position = position;
		Rotation = rotation;
		Scale = scale;
	}

	public override bool OnGuestJoined(string guestUID)
	{
		return false;
	}

	public override bool OnSceneLoaded()
	{
		if (ShouldBeSpawned())
		{
			if (!PhotonNetwork.isNonMasterClientInRoom)
			{
				SetupServerSide();
			}
			return true;
		}
		return false;
	}

	public override object SetupClientSide(int rpcListenerID, string instanceUID, int sceneViewID, int recursionCount, string rpcMeta)
	{
		return null;
	}

	public virtual Item SetupServerSide()
	{
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		Item val = ItemManager.Instance.GenerateItemNetwork(ItemID);
		val.ChangeParent((Transform)null, Position, Extensions.EulerToQuat(Rotation));
		val.SetForceSyncPos();
		val.SaveType = (SaveTypes)2;
		val.IsPickable = false;
		val.HasPhysicsWhenWorld = true;
		return val;
	}
}
public class SynchronizedNPCScene
{
	public string Scene;

	public Vector3 Position;

	public Vector3 Rotation;

	public Factions? Faction;

	public bool Sheathed;

	public SpellCastType Pose;

	public string RPCMeta;

	public int[] DefaultEquipment;

	public int[] ModdedEquipment;

	public Func<bool> ShouldSpawnInScene;

	public SynchronizedNPCScene(string scene, Vector3 position, Vector3 rotation, Factions? faction = null, bool sheathed = true, SpellCastType pose = -1, string rpcMeta = null, int[] defaultEquipment = null, int[] moddedEquipment = null, Func<bool> shouldSpawnInScene = null)
	{
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: 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)
		Scene = scene;
		Position = position;
		Rotation = rotation;
		Faction = faction;
		Sheathed = sheathed;
		Pose = pose;
		RPCMeta = rpcMeta;
		DefaultEquipment = defaultEquipment;
		ModdedEquipment = moddedEquipment;
		ShouldSpawnInScene = shouldSpawnInScene ?? ((Func<bool>)(() => true));
	}
}
public class SynchronizedNPC : SynchronizedWorldObject
{
	public enum HairColors
	{
		BrownMedium,
		BrownBright,
		BrownDark,
		Black,
		Blonde,
		White,
		Red,
		Blue,
		Green,
		Orange,
		Purple
	}

	public enum HairStyles
	{
		Bald,
		Basic,
		PonyTail,
		Wild,
		CombedBack,
		PonyTailBraids,
		BraidsBack,
		Bun,
		MaleShort,
		MaleMedium,
		MaleLong,
		CornrowsMedium,
		CornrowsLong,
		CornrowsShort,
		Ball
	}

	public int[] DefaultEquipment = new int[0];

	public int[] ModdedEquipment = new int[0];

	public Vector3 Scale;

	public string RPCMeta;

	public Factions Faction;

	private Character localCharacter;

	private AIRoot aiRoot;

	public VisualData VisualData;

	public List<SynchronizedNPCScene> Scenes = new List<SynchronizedNPCScene>();

	public SynchronizedNPCScene ActiveScene;

	public SynchronizedNPC(string identifierName, int rpcListenerID, int[] defaultEquipment = null, int[] moddedEquipment = null, Vector3? scale = null, Factions? faction = null, VisualData visualData = null)
		: base(identifierName, rpcListenerID)
	{
		//IL_0066: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: Unknown result type (might be due to invalid IL or missing references)
		//IL_006b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0073: 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)
		DefaultEquipment = defaultEquipment ?? new int[0];
		ModdedEquipment = moddedEquipment ?? new int[0];
		Scale = (Vector3)(((??)scale) ?? Vector3.one);
		Faction = faction.GetValueOrDefault();
		VisualData = visualData;
	}

	public void AddToScene(SynchronizedNPCScene scene)
	{
		Scenes.Add(scene);
	}

	public void AssignAI(AIRoot aiRoot)
	{
		this.aiRoot = aiRoot;
	}

	public GameObject GetGameObject()
	{
		return GameObject.Find("UNPC_" + IdentifierName);
	}

	public object GetSynchronizedObject(string instanceUID)
	{
		return CharacterManager.Instance.GetCharacter(instanceUID);
	}

	public override bool ShouldBeSpawned()
	{
		foreach (SynchronizedNPCScene scene in Scenes)
		{
			if (scene.ShouldSpawnInScene() && scene.Scene == SceneManagerHelper.ActiveSceneName)
			{
				ActiveScene = scene;
				return true;
			}
		}
		return false;
	}

	public override bool OnSceneLoaded()
	{
		if (ShouldBeSpawned())
		{
			if (!PhotonNetwork.isNonMasterClientInRoom)
			{
				int num = PhotonNetwork.AllocateSceneViewID();
				GameObject gameObject = GetGameObject();
				if ((Object)(object)gameObject == (Object)null)
				{
					SetupServerSide();
					((MonoBehaviour)SynchronizedWorldObjectManager.Instance).photonView.RPC("SetupClientSide", (PhotonTargets)0, new object[5] { RPCListenerID, Uid, num, 0, ActiveScene.RPCMeta });
					return true;
				}
			}
		}
		else
		{
			GameObject gameObject2 = GetGameObject();
			if (gameObject2 != null)
			{
				Object.DestroyImmediate((Object)(object)gameObject2);
			}
		}
		return false;
	}

	public override bool OnGuestJoined(string guestUID)
	{
		if (ShouldBeSpawned())
		{
			if (!PhotonNetwork.isNonMasterClientInRoom)
			{
				int num = PhotonNetwork.AllocateSceneViewID();
				GameObject gameObject = GetGameObject();
				if ((Object)(object)gameObject == (Object)null)
				{
					((MonoBehaviour)SynchronizedWorldObjectManager.Instance).photonView.RPC("SetupClientSide", (PhotonTargets)0, new object[5] { RPCListenerID, Uid, num, 0, ActiveScene.RPCMeta });
					return true;
				}
			}
		}
		else
		{
			GameObject gameObject2 = GetGameObject();
			if (gameObject2 != null)
			{
				Object.DestroyImmediate((Object)(object)gameObject2);
			}
		}
		return false;
	}

	public override object SetupClientSide(int rpcListenerID, string instanceUID, int sceneViewID, int recursionCount, string rpcMeta)
	{
		//IL_0105: Unknown result type (might be due to invalid IL or missing references)
		//IL_010b: Expected O, but got Unknown
		//IL_0117: Unknown result type (might be due to invalid IL or missing references)
		//IL_012e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0133: Unknown result type (might be due to invalid IL or missing references)
		//IL_0193: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
		//IL_01be: Unknown result type (might be due to invalid IL or missing references)
		if (RPCListenerID != rpcListenerID)
		{
			return null;
		}
		ActiveScene = Scenes.FirstOrDefault((SynchronizedNPCScene x) => x.RPCMeta == rpcMeta);
		int num = 200;
		object synchronizedObject = GetSynchronizedObject(instanceUID);
		Character val = (Character)((synchronizedObject is Character) ? synchronizedObject : null);
		if ((Object)(object)val == (Object)null)
		{
			if (recursionCount * num < 20000)
			{
				DelayedTask.GetTask(num).ContinueWith((Task _) => SetupClientSide(rpcListenerID, instanceUID, sceneViewID, recursionCount + 1, rpcMeta));
				Console.Read();
				return null;
			}
			Debug.Log((object)("SynchronizedNPC with UID " + instanceUID + " could not fetched from server"));
			return null;
		}
		GameObject val2 = new GameObject("UNPC_" + IdentifierName);
		val2.transform.position = ActiveScene.Position;
		val2.transform.rotation = Quaternion.Euler(ActiveScene.Rotation);
		GameObject gameObject = ((Component)val).gameObject;
		if (VisualData != null)
		{
			((MonoBehaviour)TinyHelper.Instance).StartCoroutine(SL_Character.SetVisuals(val, ((object)VisualData).ToString()));
		}
		gameObject.transform.parent = val2.transform;
		gameObject.transform.position = val2.transform.position;
		gameObject.transform.rotation = val2.transform.rotation;
		gameObject.transform.localScale = Scale;
		Object.DestroyImmediate((Object)(object)gameObject.GetComponent<StartingEquipment>());
		((Behaviour)val.Stats).enabled = false;
		Weapon currentWeapon = val.CurrentWeapon;
		if (currentWeapon != null && ((Equipment)currentWeapon).TwoHanded)
		{
			val.LeftHandEquipment = (Equipment)(object)val.CurrentWeapon;
			val.LeftHandChanged();
		}
		if ((Object)(object)val.CurrentWeapon != (Object)null)
		{
			val.Sheathed = ActiveScene.Sheathed;
		}
		localCharacter = val;
		return val;
	}

	public void AITick()
	{
		//IL_004c: 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_008b: Expected I4, but got Unknown
		DelayedTask.GetTask(1000).ContinueWith(delegate
		{
			AITick();
		});
		Console.Read();
		if ((Object)(object)localCharacter != (Object)null)
		{
			SpellCastType[] array = (SpellCastType[])(object)new SpellCastType[2]
			{
				(SpellCastType)55,
				(SpellCastType)41
			};
			if (UnityEngineExtensions.Contains<SpellCastType>(array, ActiveScene.Pose) && localCharacter.InLocomotion)
			{
				localCharacter.Animator.SetInteger("SpellType", (int)ActiveScene.Pose);
				localCharacter.Animator.SetTrigger("Spell");
			}
		}
	}

	public object SetupServerSide()
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_0048: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
		UID val = UID.Generate();
		string text = ((object)(UID)(ref val)).ToString();
		GameObject gameObject = ((Component)TinyCharacterManager.SpawnCharacter(text, ActiveScene.Position, ActiveScene.Rotation)).gameObject;
		gameObject.transform.rotation = Quaternion.Euler(ActiveScene.Rotation);
		Character component = gameObject.GetComponent<Character>();
		At.SetField<Character>(component, "m_instantiationType", (object)(CharacterInstantiationTypes)2);
		int[] array = ActiveScene.DefaultEquipment ?? DefaultEquipment;
		foreach (int num in array)
		{
			? val2 = component.Inventory.Equipment;
			Item itemPrefab = ResourcesPrefabManager.Instance.GetItemPrefab(num);
			((CharacterEquipment)val2).EquipInstantiate((Equipment)(object)((itemPrefab is Equipment) ? itemPrefab : null));
		}
		int[] array2 = ActiveScene.ModdedEquipment ?? ModdedEquipment;
		for (int j = 0; j < array2.Length; j++)
		{
			int num2 = array2[j];
			if (ResourcesPrefabManager.Instance.ContainsItemPrefab(num2.ToString()))
			{
				Item obj = ItemManager.Instance.GenerateItemNetwork(num2);
				Equipment val3 = (Equipment)(object)((obj is Equipment) ? obj : null);
				component.Inventory.TakeItem(((Item)val3).UID);
				At.Invoke<CharacterEquipment>(component.Inventory.Equipment, "EquipWithoutAssociating", new Type[2]
				{
					typeof(Equipment),
					typeof(bool)
				}, new object[2] { val3, false });
			}
		}
		Weapon currentWeapon = component.CurrentWeapon;
		if (currentWeapon != null && ((Equipment)currentWeapon).TwoHanded)
		{
			component.LeftHandEquipment = (Equipment)(object)component.CurrentWeapon;
			component.LeftHandChanged();
		}
		if ((Object)(object)component.CurrentWeapon != (Object)null)
		{
			component.Sheathed = ActiveScene.Sheathed;
		}
		component.ChangeFaction((Factions)(((??)ActiveScene.Faction) ?? Faction), true);
		gameObject.SetActive(true);
		DelayedTask.GetTask(1000).ContinueWith(delegate
		{
			AITick();
		});
		Console.Read();
		Uid = text;
		return text;
	}
}

#define DEBUG
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.Threading;
using System.Threading.Tasks;
using BepInEx;
using HarmonyLib;
using Localizer;
using NodeCanvas.DialogueTrees;
using NodeCanvas.Framework;
using NodeCanvas.Tasks.Actions;
using NodeCanvas.Tasks.Conditions;
using Photon;
using TinyHelper.Effects;
using TinyHelper.Interfaces;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("0.0.0.0")]
public static class TinyHelpers
{
	public static void Shuffle<T>(this IList<T> list)
	{
		Random random = new Random();
		int count = list.Count;
		for (int num = list.Count - 1; num > 1; num--)
		{
			int index = random.Next(num + 1);
			T value = list[index];
			list[index] = list[num];
			list[num] = value;
		}
	}
}
namespace TinyHelper
{
	public static class At
	{
		public static BindingFlags flags = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;

		public static object Call(object obj, string method, params object[] args)
		{
			MethodInfo method2 = obj.GetType().GetMethod(method, flags);
			if (method2 != null)
			{
				return method2.Invoke(obj, args);
			}
			return null;
		}

		public static void SetValue<T>(T value, Type type, object obj, string field)
		{
			FieldInfo field2 = type.GetField(field, flags);
			if (field2 != null)
			{
				field2.SetValue(obj, value);
			}
		}

		public static object GetValue(Type type, object obj, string value)
		{
			FieldInfo field = type.GetField(value, flags);
			if (field != null)
			{
				return field.GetValue(obj);
			}
			return null;
		}

		public static void InheritBaseValues(object _derived, object _base)
		{
			FieldInfo[] fields = _base.GetType().GetFields(flags);
			foreach (FieldInfo fieldInfo in fields)
			{
				try
				{
					_derived.GetType().GetField(fieldInfo.Name).SetValue(_derived, fieldInfo.GetValue(_base));
				}
				catch
				{
				}
			}
		}
	}
	public class QuestKnowledgeCondition : EffectCondition
	{
		public int[] Quests;

		public LogicType Logic = LogicType.Any;

		protected override bool CheckIsValid(Character _affectedCharacter)
		{
			return QuestRequirements.HasQuestKnowledge(_affectedCharacter, Quests, Logic);
		}
	}
	public class StatusEffectsCondition : EffectCondition
	{
		public enum LogicType
		{
			Any,
			All
		}

		public string[] StatusEffectNames;

		public LogicType Logic = LogicType.Any;

		protected override bool CheckIsValid(Character _affectedCharacter)
		{
			StatusEffectManager statusEffectManager = ((_affectedCharacter != null) ? _affectedCharacter.StatusEffectMngr : null);
			if (statusEffectManager != null)
			{
				IEnumerable<bool> source = StatusEffectNames.Select((string x) => (Object)(object)statusEffectManager.GetStatusEffectOfName(x) != (Object)null);
				return (Logic == LogicType.Any) ? source.Any((bool x) => x) : source.All((bool x) => x);
			}
			return false;
		}
	}
	public class AddNewStatusEffectRandom : AddStatusEffectRandom
	{
		protected override bool TryTriggerConditions()
		{
			List<StatusEffect> list = base.Statuses.ToList();
			list.Shuffle();
			base.ForceID = -1;
			for (int i = 0; i < list.Count; i++)
			{
				StatusEffect val = list[i];
				if (!((Object)(object)val == (Object)null) && !((Object)(object)((Effect)this).m_affectedCharacter == (Object)null) && !((Effect)this).m_affectedCharacter.StatusEffectMngr.HasStatusEffect(val.EffectFamily))
				{
					base.ForceID = UnityEngineExtensions.IndexOf<StatusEffect>(base.Statuses, val);
					break;
				}
			}
			return ((AddStatusEffectRandom)this).TryTriggerConditions();
		}
	}
	public class CooldownChangeEffect : Effect
	{
		public float HitKnockbackCooldown = -1f;

		protected override void ActivateLocally(Character _affectedCharacter, object[] _infos)
		{
			Item parentItem = ((Effect)this).ParentItem;
			Skill val = (Skill)(object)((parentItem is Skill) ? parentItem : null);
			if (val != null && HitKnockbackCooldown != -1f && _affectedCharacter.IsInKnockback)
			{
				At.SetValue(HitKnockbackCooldown, typeof(Skill), val, "m_remainingCooldownTime");
			}
		}
	}
	public class EquipSkillDurabilityCondition : EquipDurabilityCondition
	{
		protected override bool CheckIsValid(Character _affectedCharacter)
		{
			Skill component = ((Component)((Component)this).transform.parent.parent).gameObject.GetComponent<Skill>();
			if (component != null)
			{
				base.DurabilityRequired = component.DurabilityCost;
			}
			return ((EquipDurabilityCondition)this).CheckIsValid(_affectedCharacter);
		}

		public static ActivationCondition AddToSkill(Skill skill, EquipmentSlotIDs slot)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			Transform orMake = TinyGameObjectManager.GetOrMake(((Component)skill).transform, "AdditionalActivationConditions", setActive: true, dontDestroyOnLoad: true);
			GameObject gameObject = ((Component)TinyGameObjectManager.GetOrMake(orMake, "EquipSkillDurabilityCondition", setActive: true, dontDestroyOnLoad: true)).gameObject;
			ActivationCondition val = new ActivationCondition();
			EquipSkillDurabilityCondition equipSkillDurabilityCondition = gameObject.AddComponent<EquipSkillDurabilityCondition>();
			((EquipDurabilityCondition)equipSkillDurabilityCondition).EquipmentSlot = slot;
			val.Condition = (EffectCondition)(object)equipSkillDurabilityCondition;
			At.SetValue("A required piece of equipment is missing or too damaged to be used this way.", typeof(ActivationCondition), val, "m_defaultMessage");
			List<ActivationCondition> list = (At.GetValue(typeof(Skill), skill, "m_additionalConditions") as ActivationCondition[])?.ToList() ?? new List<ActivationCondition>();
			list.Add(val);
			At.SetValue(list.ToArray(), typeof(Skill), skill, "m_additionalConditions");
			return val;
		}

		public static ActivationCondition AddToSkillNotBroken(Skill skill, EquipmentSlotIDs slot)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			Transform orMake = TinyGameObjectManager.GetOrMake(((Component)skill).transform, "AdditionalActivationConditions", setActive: true, dontDestroyOnLoad: true);
			GameObject gameObject = ((Component)TinyGameObjectManager.GetOrMake(orMake, "EquipDurabilityCondition", setActive: true, dontDestroyOnLoad: true)).gameObject;
			ActivationCondition val = new ActivationCondition();
			EquipDurabilityCondition val2 = gameObject.AddComponent<EquipDurabilityCondition>();
			val2.EquipmentSlot = slot;
			val2.DurabilityRequired = 0f;
			val.Condition = (EffectCondition)(object)val2;
			At.SetValue("A required piece of equipment is missing or broken.", typeof(ActivationCondition), val, "m_defaultMessage");
			List<ActivationCondition> list = (At.GetValue(typeof(Skill), skill, "m_additionalConditions") as ActivationCondition[])?.ToList() ?? new List<ActivationCondition>();
			list.Add(val);
			At.SetValue(list.ToArray(), typeof(Skill), skill, "m_additionalConditions");
			return val;
		}
	}
	public class AffectCorruption : Effect
	{
		public float AffectQuantity = 0f;

		public bool AffectOwner = false;

		public bool IsRaw = false;

		protected override KeyValuePair<string, Type>[] GenerateSignature()
		{
			return new KeyValuePair<string, Type>[1]
			{
				new KeyValuePair<string, Type>("Value", typeof(float))
			};
		}

		public override void SetValue(string[] _data)
		{
			if (_data == null || _data.Length >= 1)
			{
				float.TryParse(_data[0], out AffectQuantity);
			}
		}

		protected override void ActivateLocally(Character _affectedCharacter, object[] _infos)
		{
			if (AffectOwner)
			{
				_affectedCharacter = ((Effect)this).OwnerCharacter;
			}
			if ((Object)(object)_affectedCharacter != (Object)null && _affectedCharacter.Alive && Object.op_Implicit((Object)(object)_affectedCharacter.PlayerStats))
			{
				_affectedCharacter.PlayerStats.AffectCorruptionLevel(AffectQuantity, !IsRaw);
			}
		}
	}
	public class UseMana : Effect
	{
		public float UsedMana = 0f;

		protected override void ActivateLocally(Character _affectedCharacter, object[] _infos)
		{
			_affectedCharacter.Stats.UseMana((Tag[])null, UsedMana);
		}
	}
	public class SpecificImbueCondition : EffectCondition
	{
		public ImbueEffectPreset imbueEffectPreset;

		private bool inverse = false;

		protected override bool CheckIsValid(Character _affectedCharacter)
		{
			Weapon val = ((_affectedCharacter != null) ? _affectedCharacter.CurrentWeapon : null);
			return val != null && val.HasImbuePreset(imbueEffectPreset);
		}

		public static ActivationCondition AddToSkill(Skill skill, ImbueEffectPreset imbueEffectPreset, bool inverse = false)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			GameObject val = new GameObject("SpecificImbueCondition");
			ActivationCondition val2 = new ActivationCondition();
			SpecificImbueCondition specificImbueCondition = val.AddComponent<SpecificImbueCondition>();
			Object.DontDestroyOnLoad((Object)(object)specificImbueCondition);
			val.SetActive(false);
			val2.Condition = (EffectCondition)(object)specificImbueCondition;
			specificImbueCondition.inverse = inverse;
			specificImbueCondition.imbueEffectPreset = imbueEffectPreset;
			At.SetValue("You do not have the required imbue effect.", typeof(ActivationCondition), val2, "m_defaultMessage");
			List<ActivationCondition> list = (At.GetValue(typeof(Skill), skill, "m_additionalConditions") as ActivationCondition[])?.ToList() ?? new List<ActivationCondition>();
			list.Add(val2);
			At.SetValue(list.ToArray(), typeof(Skill), skill, "m_additionalConditions");
			return val2;
		}
	}
	public class ExtendedAddStatusEffect : AddStatusEffect
	{
		public bool ExtendDuration = false;

		protected override void ActivateLocally(Character _targetCharacter, object[] _infos)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			StatusEffect status = base.Status;
			if (ExtendDuration)
			{
				bool? obj;
				if (_targetCharacter == null)
				{
					obj = null;
				}
				else
				{
					StatusEffectManager statusEffectMngr = _targetCharacter.StatusEffectMngr;
					obj = ((statusEffectMngr != null) ? new bool?(statusEffectMngr.HasStatusEffect(status.IdentifierName)) : null);
				}
				bool? flag = obj;
				if (flag.GetValueOrDefault())
				{
					StatusData statusData = status.StatusData;
					status.StatusData = new StatusData(statusData);
					StatusEffect statusEffectOfName = _targetCharacter.StatusEffectMngr.GetStatusEffectOfName(status.IdentifierName);
					float num = ((statusEffectOfName != null) ? statusEffectOfName.RemainingLifespan : 0f);
					float num2 = ((status.RemainingLifespan > 0f) ? status.RemainingLifespan : status.StartLifespan);
					status.StatusData.LifeSpan = num2 + num;
					((AddStatusEffect)this).ActivateLocally(_targetCharacter, _infos);
					status.StatusData = statusData;
					return;
				}
			}
			((AddStatusEffect)this).ActivateLocally(_targetCharacter, _infos);
		}
	}
	public static class AnimatorExtension
	{
		public static bool HasParameter(this Animator animator, string paramName)
		{
			AnimatorControllerParameter[] parameters = animator.parameters;
			foreach (AnimatorControllerParameter val in parameters)
			{
				if (val.name == paramName)
				{
					return true;
				}
			}
			return false;
		}
	}
	public class TinyCharacterManager
	{
		public static Character SpawnCharacter(string uid, Vector3 position, Vector3 rotation)
		{
			//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_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			Character character = CharacterManager.Instance.GetCharacter(uid);
			if ((Object)(object)character != (Object)null)
			{
				return character;
			}
			object[] array = new object[4]
			{
				4,
				"NewPlayerPrefab",
				uid,
				string.Empty
			};
			GameObject val = PhotonNetwork.InstantiateSceneObject("_characters/NewPlayerPrefab", position, Quaternion.Euler(rotation), (byte)0, array);
			val.SetActive(false);
			Character component = val.GetComponent<Character>();
			component.SetUID(UID.op_Implicit(uid));
			At.SetValue<Character>(component, typeof(int), 1, "m_isAI");
			return component;
		}
	}
	public class TinyDialogueManager
	{
		public static GameObject AssignMerchantTemplate(Transform parentTransform)
		{
			//IL_0025: 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)
			GameObject val = Object.Instantiate<GameObject>(Resources.Load<GameObject>("editor/templates/MerchantTemplate"));
			val.transform.parent = parentTransform;
			val.transform.position = parentTransform.position;
			val.transform.rotation = parentTransform.rotation;
			return val;
		}

		public static GameObject AssignTrainerTemplate(Transform parentTransform)
		{
			//IL_0025: 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)
			GameObject val = Object.Instantiate<GameObject>(Resources.Load<GameObject>("editor/templates/TrainerTemplate"));
			val.transform.parent = parentTransform;
			val.transform.position = parentTransform.position;
			val.transform.rotation = parentTransform.rotation;
			return val;
		}

		public static DialogueActor SetDialogueActorName(GameObject dialogueGameObject, string name)
		{
			DialogueActor componentInChildren = dialogueGameObject.GetComponentInChildren<DialogueActor>();
			componentInChildren.SetName(name);
			return componentInChildren;
		}

		public static Merchant SetMerchant(GameObject merchantTemplate, UID merchantUID)
		{
			return merchantTemplate.GetComponentInChildren<Merchant>();
		}

		public static Trainer SetTrainerSkillTree(GameObject trainerTemplate, UID skillTreeUID)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			Trainer componentInChildren = trainerTemplate.GetComponentInChildren<Trainer>();
			At.SetValue<UID>(skillTreeUID, typeof(Trainer), componentInChildren, "m_skillTreeUID");
			return componentInChildren;
		}

		public static Graph GetDialogueGraph(GameObject trainerTemplate)
		{
			DialogueTreeController componentInChildren = trainerTemplate.GetComponentInChildren<DialogueTreeController>();
			return ((GraphOwner)componentInChildren).graph;
		}

		public static void SetActorReference(Graph graph, DialogueActor actor)
		{
			List<ActorParameter> list = At.GetValue(typeof(DialogueTree), (graph is DialogueTree) ? graph : null, "_actorParameters") as List<ActorParameter>;
			list[0].actor = (IDialogueActor)(object)actor;
			list[0].name = actor.name;
		}

		public static ActionNode MakeMerchantDialogueAction(Graph graph, Merchant merchant)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			ActionNode val = graph.AddNode<ActionNode>();
			ShopDialogueAction val2 = new ShopDialogueAction
			{
				Merchant = new BBParameter<Merchant>(merchant)
			};
			BBParameter<Character> obj = new BBParameter<Character>();
			((BBParameter)obj).name = "gInstigator";
			val2.PlayerCharacter = obj;
			ShopDialogueAction action = val2;
			val.action = (ActionTask)(object)action;
			return val;
		}

		public static ActionNode MakeTrainDialogueAction(Graph graph, Trainer trainer)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			ActionNode val = graph.AddNode<ActionNode>();
			TrainDialogueAction val2 = new TrainDialogueAction
			{
				Trainer = new BBParameter<Trainer>(trainer)
			};
			BBParameter<Character> obj = new BBParameter<Character>();
			((BBParameter)obj).name = "gInstigator";
			val2.PlayerCharacter = obj;
			TrainDialogueAction action = val2;
			val.action = (ActionTask)(object)action;
			return val;
		}

		public static ActionNode MakeStartQuest(Graph graph, int questID)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			ActionNode val = graph.AddNode<ActionNode>();
			GiveQuest val3 = (GiveQuest)(object)(val.action = (ActionTask)new GiveQuest());
			ref BBParameter<Quest> quest = ref val3.quest;
			Item itemPrefab = ResourcesPrefabManager.Instance.GetItemPrefab(questID);
			quest = new BBParameter<Quest>((Quest)(object)((itemPrefab is Quest) ? itemPrefab : null));
			return val;
		}

		public static ActionNode MakeQuestEvent(Graph graph, string EventUID)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			ActionNode val = graph.AddNode<ActionNode>();
			SendQuestEvent val3 = (SendQuestEvent)(object)(val.action = (ActionTask)new SendQuestEvent());
			val3.QuestEventRef = new QuestEventReference
			{
				EventUID = EventUID
			};
			return val;
		}

		public static ConditionNode MakeEventOccuredCondition(Graph graph, string EventUID, int MinStack)
		{
			//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_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			ConditionNode val = graph.AddNode<ConditionNode>();
			val.condition = (ConditionTask)new Condition_QuestEventOccured
			{
				QuestEventRef = new QuestEventReference
				{
					EventUID = EventUID
				},
				MinStack = MinStack
			};
			return val;
		}

		public static ConditionNode MakeHasItemCondition(Graph graph, int itemID, int MinStack)
		{
			//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_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//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_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			ConditionNode val = graph.AddNode<ConditionNode>();
			Condition_OwnsItem val2 = new Condition_OwnsItem();
			BBParameter<Character> obj = new BBParameter<Character>();
			((BBParameter)obj).name = "gInstigator";
			val2.character = obj;
			val2.item = new BBParameter<ItemReference>(new ItemReference
			{
				ItemID = itemID
			});
			val2.minAmount = new BBParameter<int>(MinStack);
			val2.itemMustBeEquiped = new BBParameter<bool>(false);
			val2.SaveMatchingContainerVariable = null;
			val.condition = (ConditionTask)val2;
			return val;
		}

		public static ConditionNode MakeHasItemConditionSimple(Graph graph, int itemID, int MinStack, int enchantment = 0)
		{
			//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_0025: 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)
			//IL_004c: Expected O, but got Unknown
			ConditionNode val = graph.AddNode<ConditionNode>();
			Condition_SimpleOwnsItem val2 = new Condition_SimpleOwnsItem();
			BBParameter<Character> obj = new BBParameter<Character>();
			((BBParameter)obj).name = "gInstigator";
			val2.character = obj;
			val2.item = new BBParameter<Item>(ResourcesPrefabManager.Instance.GetItemPrefab(itemID));
			val2.minAmount = new BBParameter<int>(MinStack);
			val.condition = (ConditionTask)val2;
			return val;
		}

		public static ActionNode MakeGiveItemReward(Graph graph, int itemID, Receiver receiver, int quantity = 1)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			ActionNode val = graph.AddNode<ActionNode>();
			GiveReward val3 = (GiveReward)(object)(val.action = (ActionTask)new GiveReward());
			val3.RewardReceiver = receiver;
			ItemQuantity val4 = new ItemQuantity();
			ItemReference val5 = new ItemReference();
			val5.ItemID = itemID;
			val4.Item = new BBParameter<ItemReference>(val5);
			val4.Quantity = BBParameter<int>.op_Implicit(quantity);
			val3.ItemReward = new List<ItemQuantity> { val4 };
			return val;
		}

		public static ActionNode MakeResignItem(Graph graph, int itemID, Receiver provider, int quantity = 1, int enchantment = 0)
		{
			//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_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			ActionNode val = graph.AddNode<ActionNode>();
			RemoveItem val2 = new RemoveItem();
			BBParameter<Character> obj = new BBParameter<Character>();
			((BBParameter)obj).name = "gInstigator";
			val2.fromCharacter = obj;
			val2.Items = new List<BBParameter<ItemReference>>
			{
				new BBParameter<ItemReference>(new ItemReference
				{
					ItemID = itemID
				})
			};
			val2.Amount = new List<BBParameter<int>>
			{
				new BBParameter<int>(quantity)
			};
			val.action = (ActionTask)val2;
			return val;
		}

		public static StatementNodeExt MakeStatementNode(Graph graph, string name, string statementText)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			StatementNodeExt val = graph.AddNode<StatementNodeExt>();
			val.statement = new Statement(statementText);
			val.SetActorName(name);
			return val;
		}

		public static MultipleChoiceNodeExt MakeMultipleChoiceNode(Graph graph, string[] statementTexts)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			//IL_0037: Expected O, but got Unknown
			MultipleChoiceNodeExt val = graph.AddNode<MultipleChoiceNodeExt>();
			foreach (string text in statementTexts)
			{
				val.availableChoices.Add(new Choice
				{
					statement = new Statement
					{
						text = text
					}
				});
			}
			return val;
		}

		public static void ChainNodes(Graph graph, Node[] nodes)
		{
			Node val = null;
			foreach (Node val2 in nodes)
			{
				if (val != null)
				{
					graph.ConnectNodes(val, val2, -1, -1);
				}
				val = val2;
			}
		}

		public static void ConnectMultipleChoices(Graph graph, Node baseNode, Node[] nodes)
		{
			for (int i = 0; i < nodes.Length; i++)
			{
				graph.ConnectNodes(baseNode, nodes[i], i, -1);
			}
		}
	}
	public class TinyGameObjectManager
	{
		public static Transform GetOrMake(Transform parent, string child, bool setActive, bool dontDestroyOnLoad)
		{
			return parent.Find(child) ?? MakeFreshObject(child, setActive, dontDestroyOnLoad, parent).transform;
		}

		public static GameObject InstantiateClone(GameObject sourceGameObject, bool setActive, bool dontDestroyOnLoad)
		{
			return InstantiateClone(sourceGameObject, ((Object)sourceGameObject).name + "(Clone)", setActive, dontDestroyOnLoad);
		}

		public static GameObject InstantiateClone(GameObject sourceGameObject, string newGameObjectName, bool setActive, bool dontDestroyOnLoad)
		{
			GameObject val = Object.Instantiate<GameObject>(sourceGameObject);
			val.SetActive(setActive);
			((Object)val).name = newGameObjectName;
			if (dontDestroyOnLoad)
			{
				Object.DontDestroyOnLoad((Object)(object)val);
			}
			return val;
		}

		public static Transform MakeFreshTransform(Transform parent, string child, bool setActive, bool dontDestroyOnLoad)
		{
			return MakeFreshObject(child, setActive, dontDestroyOnLoad, parent).transform;
		}

		public static GameObject MakeFreshObject(string newGameObjectName, bool setActive, bool dontDestroyOnLoad, Transform parent = null)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			GameObject val = new GameObject(newGameObjectName);
			val.SetActive(setActive);
			if ((Object)(object)parent != (Object)null)
			{
				val.transform.SetParent(parent);
			}
			if (dontDestroyOnLoad)
			{
				RecursiveDontDestroyOnLoad(val.transform);
			}
			return val;
		}

		public static void RecursiveDontDestroyOnLoad(Transform transform)
		{
			Transform val = transform;
			while ((Object)(object)val.parent != (Object)null)
			{
				val = val.parent;
			}
			Object.DontDestroyOnLoad((Object)(object)((Component)val).gameObject);
		}
	}
	public enum Behaviour
	{
		Add,
		Purge,
		Replace
	}
	public class TinyItemManager
	{
		private static Dictionary<int, ItemLocalization> m_ItemLocalizationDictionary;

		private static Dictionary<string, Item> m_ItemPrefabDictionary;

		private static Dictionary<int, ItemLocalization> ItemLocalizationDictionary
		{
			get
			{
				if (m_ItemLocalizationDictionary == null)
				{
					m_ItemLocalizationDictionary = At.GetValue(typeof(LocalizationManager), LocalizationManager.Instance, "m_itemLocalization") as Dictionary<int, ItemLocalization>;
				}
				return m_ItemLocalizationDictionary;
			}
		}

		private static Dictionary<string, Item> ItemPrefabDictionary
		{
			get
			{
				if (m_ItemPrefabDictionary == null)
				{
					m_ItemPrefabDictionary = At.GetValue(typeof(ResourcesPrefabManager), null, "ITEM_PREFABS") as Dictionary<string, Item>;
				}
				return m_ItemPrefabDictionary;
			}
		}

		public static bool SetLegacyResult(int itemID, int legacyOutcomeID)
		{
			Item itemPrefab = ResourcesPrefabManager.Instance.GetItemPrefab(itemID);
			if ((Object)(object)itemPrefab != (Object)null)
			{
				itemPrefab.LegacyItemID = legacyOutcomeID;
				return true;
			}
			return false;
		}

		public static bool AddEnchantingOption(int itemID, int enchantingRecipeID)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			Item itemPrefab = ResourcesPrefabManager.Instance.GetItemPrefab(itemID);
			EnchantmentRecipe enchantmentRecipeForID = RecipeManager.Instance.GetEnchantmentRecipeForID(enchantingRecipeID);
			if ((Object)(object)enchantmentRecipeForID != (Object)null && (Object)(object)itemPrefab != (Object)null)
			{
				List<IngredientData> list = enchantmentRecipeForID.CompatibleEquipments.CompatibleEquipments.ToList();
				list.Add(new IngredientData
				{
					Type = (IngredientType)1,
					SpecificIngredient = itemPrefab
				});
				enchantmentRecipeForID.CompatibleEquipments = new EquipmentData
				{
					EquipmentTag = enchantmentRecipeForID.CompatibleEquipments.EquipmentTag,
					CompatibleEquipments = list.ToArray()
				};
				return true;
			}
			return false;
		}

		public static Item MakeItem(int newID, int targetID, string name = null, string description = null, string identifierName = null)
		{
			Item val = TryCloneTargetItem(newID, targetID, newID + "_" + identifierName);
			ApplyNameAndDescription(val, name, description);
			return val;
		}

		public static Skill MakeSkill(int newID, int targetID, string name = null, string description = null, string identifierName = null, int? manaCost = 0, int? staminaCost = 0, int? healthCost = 0, bool? ignoreLearnNotification = null, bool? hideInUI = null)
		{
			Item obj = MakeItem(newID, targetID, name, description, identifierName);
			Skill val = (Skill)(object)((obj is Skill) ? obj : null);
			if (manaCost.HasValue)
			{
				val.ManaCost = manaCost.GetValueOrDefault();
			}
			if (healthCost.HasValue)
			{
				val.HealthCost = healthCost.GetValueOrDefault();
			}
			if (staminaCost.HasValue)
			{
				val.StaminaCost = staminaCost.GetValueOrDefault();
			}
			val.IgnoreLearnNotification = ignoreLearnNotification.GetValueOrDefault();
			return val;
		}

		public static Item TryCloneTargetItem(int newID, int targetID, string identifierName = null)
		{
			Dictionary<string, Item> itemPrefabDictionary = ItemPrefabDictionary;
			Item item = GetItem(targetID.ToString());
			if ((Object)(object)item == (Object)null)
			{
				TinyHelper.TinyHelperPrint("Could not find target item with ID " + targetID + ".");
				return null;
			}
			if ((Object)(object)((Component)item).gameObject.GetComponent<Item>() == (Object)null)
			{
				TinyHelper.TinyHelperPrint(((Object)item).name + " is does not have an Item component.");
				return null;
			}
			GameObject val = Object.Instantiate<GameObject>(((Component)item).gameObject);
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			Item component = val.GetComponent<Item>();
			component.ItemID = newID;
			((Object)component).name = identifierName ?? (newID + "_" + component.Name.Replace(" ", ""));
			ItemPrefabDictionary.Add(component.ItemID.ToString(), component);
			return component;
		}

		public static void ApplyNameAndDescription(Item item, string name, string description)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Expected O, but got Unknown
			ItemLocalization value = new ItemLocalization(name, description);
			At.SetValue(name, typeof(Item), item, "m_name");
			if (ItemLocalizationDictionary.ContainsKey(item.ItemID))
			{
				ItemLocalizationDictionary[item.ItemID] = value;
			}
			else
			{
				ItemLocalizationDictionary.Add(item.ItemID, value);
			}
		}

		private static Item GetItem(int itemID)
		{
			return GetItem(itemID.ToString());
		}

		private static Item GetItem(string itemID)
		{
			return ItemPrefabDictionary[itemID];
		}
	}
	public class TinyHelperRPCManager : MonoBehaviour
	{
		public static TinyHelperRPCManager Instance;

		internal void Start()
		{
			Instance = this;
			PhotonView val = ((Component)this).gameObject.AddComponent<PhotonView>();
			val.viewID = 954;
			Debug.Log((object)("Registered TinyHelpertRPC with ViewID " + ((MonoBehaviour)this).photonView.viewID));
		}

		[PunRPC]
		public void ApplyAddImbueEffectRPC(string weaponGUID, int infusionID, float duration)
		{
			Item item = ItemManager.Instance.GetItem(weaponGUID);
			Weapon val = (Weapon)(object)((item is Weapon) ? item : null);
			? val2 = val;
			EffectPreset effectPreset = ResourcesPrefabManager.Instance.GetEffectPreset(infusionID);
			((Weapon)val2).AddImbueEffect((ImbueEffectPreset)(object)((effectPreset is ImbueEffectPreset) ? effectPreset : null), duration, (ImbueStack)null);
		}

		[PunRPC]
		public void CharacterForceCancelRPC(string characterGUID, bool bool1, bool bool2)
		{
			Character character = CharacterManager.Instance.GetCharacter(characterGUID);
			character.ForceCancel(bool1, bool2);
		}
	}
	public class QuestRequirements
	{
		public static bool HasQuestEvent(string questEventUID)
		{
			return QuestEventManager.Instance.GetEventCurrentStack(questEventUID) > 0;
		}

		public static bool HasQuestKnowledge(Character character, int[] questIDs, LogicType logicType, bool inverted = false, bool requireCompleted = false)
		{
			bool flag = false;
			object obj;
			if (character == null)
			{
				obj = null;
			}
			else
			{
				CharacterInventory inventory = character.Inventory;
				obj = ((inventory != null) ? inventory.QuestKnowledge : null);
			}
			CharacterQuestKnowledge q = (CharacterQuestKnowledge)obj;
			if (q != null)
			{
				IEnumerable<bool> source = questIDs.Select((int x) => ((CharacterKnowledge)q).IsItemLearned(x) && (q.IsQuestCompleted(x) || !requireCompleted));
				flag = flag || ((logicType == LogicType.Any) ? source.Any((bool x) => x) : source.All((bool x) => x));
			}
			return flag ^ inverted;
		}
	}
	public enum LogicType
	{
		Any,
		All
	}
	public class SkillRequirements
	{
		public static bool SafeHasSkillKnowledge(Character character, int skillID)
		{
			bool? obj;
			if (character == null)
			{
				obj = null;
			}
			else
			{
				CharacterInventory inventory = character.Inventory;
				if (inventory == null)
				{
					obj = null;
				}
				else
				{
					CharacterSkillKnowledge skillKnowledge = inventory.SkillKnowledge;
					obj = ((skillKnowledge != null) ? new bool?(((CharacterKnowledge)skillKnowledge).IsItemLearned(skillID)) : null);
				}
			}
			bool? flag = obj;
			return flag.GetValueOrDefault();
		}
	}
	public class CustomTexture
	{
		public enum SpriteBorderTypes
		{
			None,
			Item,
			TrainerSkill
		}

		public enum IconName
		{
			m_itemIcon,
			SkillTreeIcon
		}

		private static Dictionary<string, byte[]> m_loadedTextures;

		private static Dictionary<string, byte[]> LoadedTextures
		{
			get
			{
				if (m_loadedTextures == null)
				{
					m_loadedTextures = new Dictionary<string, byte[]>();
				}
				return m_loadedTextures;
			}
		}

		public static Texture2D LoadTexture(string filePath, int mipCount, bool linear, FilterMode filterMode, float? mipMapBias = null, string rootPath = null)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			filePath = (rootPath ?? TinyHelper.PLUGIN_ROOT_PATH) + filePath;
			if (!LoadedTextures.ContainsKey(filePath))
			{
				LoadedTextures[filePath] = File.ReadAllBytes(filePath);
			}
			Texture2D val = new Texture2D(4, 4, (TextureFormat)12, mipCount > 0, linear);
			((Texture)val).filterMode = filterMode;
			((Texture)val).mipMapBias = mipMapBias ?? ((Texture)val).mipMapBias;
			ImageConversion.LoadImage(val, LoadedTextures[filePath]);
			((Texture)val).filterMode = (FilterMode)1;
			return val;
		}

		public static Sprite MakeSprite(Texture2D texture, SpriteBorderTypes spriteBorderType)
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			float num;
			float num2;
			float num3;
			float num4;
			switch (spriteBorderType)
			{
			case SpriteBorderTypes.Item:
				num = 1f;
				num2 = 2f;
				num3 = 2f;
				num4 = 3f;
				break;
			case SpriteBorderTypes.TrainerSkill:
				num = 1f;
				num2 = 1f;
				num3 = 1f;
				num4 = 2f;
				break;
			default:
				num = 0f;
				num2 = 0f;
				num3 = 0f;
				num4 = 0f;
				break;
			}
			return Sprite.Create(texture, new Rect(num, num3, (float)((Texture)texture).width - num2, (float)((Texture)texture).height - num4), new Vector2(0f, 0f), 100f, 0u);
		}
	}
	public class CooldownChangeWeaponDamageTargetHealth : WeaponDamageTargetHealth
	{
		public float ExecuteSetCooldown = -1f;

		public float HitKnockbackCooldown = -1f;

		protected override void ActivateLocally(Character _affectedCharacter, object[] _infos)
		{
			Item parentItem = ((Effect)this).ParentItem;
			Skill val = (Skill)(object)((parentItem is Skill) ? parentItem : null);
			if (val != null)
			{
				if (HitKnockbackCooldown != -1f && _affectedCharacter.IsInKnockback)
				{
					At.SetValue(HitKnockbackCooldown, typeof(Skill), val, "m_remainingCooldownTime");
				}
				bool isDead = _affectedCharacter.IsDead;
				((WeaponDamage)this).ActivateLocally(_affectedCharacter, _infos);
				if (!isDead && _affectedCharacter.IsDead && ExecuteSetCooldown != -1f)
				{
					At.SetValue(ExecuteSetCooldown, typeof(Skill), val, "m_remainingCooldownTime");
				}
			}
		}
	}
	public class ToggleEffect : Effect
	{
		public StatusEffect StatusEffectInstance;

		protected override void ActivateLocally(Character _affectedCharacter, object[] _infos)
		{
			if (_affectedCharacter.StatusEffectMngr.HasStatusEffect(StatusEffectInstance.IdentifierName))
			{
				_affectedCharacter.StatusEffectMngr.CleanseStatusEffect(((Object)StatusEffectInstance).name);
			}
			else
			{
				_affectedCharacter.StatusEffectMngr.AddStatusEffect(StatusEffectInstance, ((Effect)this).SourceCharacter);
			}
		}
	}
	public class AddThenSpreadStatus : AddStatusEffect
	{
		public float Range;

		protected override void ActivateLocally(Character _affectedCharacter, object[] _infos)
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			if (base.AffectController)
			{
				_affectedCharacter = ((Effect)this).OwnerCharacter;
			}
			if ((Object)(object)((_affectedCharacter != null) ? _affectedCharacter.StatusEffectMngr : null) == (Object)null || (Object)(object)base.Status == (Object)null)
			{
				return;
			}
			if (_affectedCharacter.StatusEffectMngr.HasStatusEffect(base.Status.IdentifierName))
			{
				List<Character> source = new List<Character>();
				CharacterManager.Instance.FindCharactersInRange(_affectedCharacter.CenterPosition, Range, ref source);
				foreach (Character item in source.Where((Character c) => !c.IsAlly(((Effect)this).SourceCharacter)))
				{
					((AddStatusEffect)this).ActivateLocally(item, _infos);
				}
			}
			((AddStatusEffect)this).ActivateLocally(_affectedCharacter, _infos);
		}
	}
	public class EmptyOffHandCondition : EffectCondition
	{
		public bool AllowDrawnTwoHandedInRight = false;

		public bool AllowSheathedTwoHandedInLeft = false;

		protected override bool CheckIsValid(Character _affectedCharacter)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_affectedCharacter == (Object)null)
			{
				goto IL_00dc;
			}
			bool? obj;
			if (_affectedCharacter == null)
			{
				obj = null;
			}
			else
			{
				Equipment leftHandEquipment = _affectedCharacter.LeftHandEquipment;
				obj = ((leftHandEquipment != null) ? new bool?(((Item)leftHandEquipment).HasTag(TinyTagManager.GetOrMakeTag("HandsFreeTag"))) : null);
			}
			if (obj ?? true)
			{
				bool? obj2;
				if (_affectedCharacter == null)
				{
					obj2 = null;
				}
				else
				{
					Weapon currentWeapon = _affectedCharacter.CurrentWeapon;
					obj2 = ((currentWeapon != null) ? new bool?(((Equipment)currentWeapon).TwoHanded) : null);
				}
				bool? flag = obj2;
				if (!flag.GetValueOrDefault())
				{
					goto IL_00dc;
				}
			}
			if (!_affectedCharacter.Sheathed && AllowDrawnTwoHandedInRight)
			{
				Weapon currentWeapon2 = _affectedCharacter.CurrentWeapon;
				if (currentWeapon2 == null || ((Equipment)currentWeapon2).TwoHandedRight)
				{
					goto IL_00dc;
				}
			}
			int result;
			if (_affectedCharacter.Sheathed && AllowSheathedTwoHandedInLeft)
			{
				Weapon currentWeapon3 = _affectedCharacter.CurrentWeapon;
				result = ((currentWeapon3 == null || ((Equipment)currentWeapon3).TwoHandedRight) ? 1 : 0);
			}
			else
			{
				result = 0;
			}
			goto IL_00dd;
			IL_00dc:
			result = 1;
			goto IL_00dd;
			IL_00dd:
			return (byte)result != 0;
		}

		public static ActivationCondition AddToSkill(Skill skill, bool allowDrawnTwoHandedInRight = false, bool allowSheathedTwoHandedInLeft = false)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			GameObject val = new GameObject("EmptyOffhandCondition");
			ActivationCondition val2 = new ActivationCondition();
			EmptyOffHandCondition emptyOffHandCondition = val.AddComponent<EmptyOffHandCondition>();
			Object.DontDestroyOnLoad((Object)(object)emptyOffHandCondition);
			val.SetActive(false);
			val2.Condition = (EffectCondition)(object)emptyOffHandCondition;
			emptyOffHandCondition.AllowDrawnTwoHandedInRight = allowDrawnTwoHandedInRight;
			emptyOffHandCondition.AllowSheathedTwoHandedInLeft = allowSheathedTwoHandedInLeft;
			At.SetValue("Requires an empty left hand.", typeof(ActivationCondition), val2, "m_defaultMessage");
			List<ActivationCondition> list = (At.GetValue(typeof(Skill), skill, "m_additionalConditions") as ActivationCondition[])?.ToList() ?? new List<ActivationCondition>();
			list.Add(val2);
			At.SetValue(list.ToArray(), typeof(Skill), skill, "m_additionalConditions");
			return val2;
		}
	}
	internal class InputEnablerEffect : Effect
	{
		protected override void ActivateLocally(Character _affectedCharacter, object[] _infos)
		{
			StatusEffect parentStatusEffect = base.m_parentStatusEffect;
			if (parentStatusEffect != null && (double)((_affectedCharacter != null) ? _affectedCharacter.AnimMoveSqMagnitude : 0f) > 0.1 && (double)parentStatusEffect.Age > 0.5)
			{
				StatusEffectManager statusEffectMngr = _affectedCharacter.StatusEffectMngr;
				if (statusEffectMngr != null)
				{
					statusEffectMngr.CleanseStatusEffect(parentStatusEffect.IdentifierName);
				}
				_affectedCharacter.ForceCancel(true, true);
			}
		}
	}
	internal class TinyUnofficialPatches
	{
	}
	[HarmonyPatch(typeof(Skill), "HasEnoughMana")]
	public class Skill_HasEnoughMana
	{
		[HarmonyPostfix]
		public static void Postfix(Skill __instance, ref bool _tryingToActivate, ref bool __result)
		{
			if (__instance.ManaCost <= 0f)
			{
				__result = true;
			}
		}
	}
	[HarmonyPatch(typeof(Skill), "HasEnoughStamina")]
	public class Skill_HasEnoughStamina
	{
		[HarmonyPostfix]
		public static void Postfix(Skill __instance, ref bool _tryingToActivate, ref bool __result)
		{
			if (__instance.StaminaCost <= 0f)
			{
				__result = true;
			}
		}
	}
	[HarmonyPatch(typeof(Skill), "HasEnoughHealth")]
	public class Skill_HasEnoughHealth
	{
		[HarmonyPostfix]
		public static void Postfix(Skill __instance, ref bool _tryingToActivate, ref bool __result)
		{
			if (__instance.HealthCost <= 0f)
			{
				__result = true;
			}
		}
	}
	public class WeaponManager
	{
		public static Dictionary<WeaponType, float> Speeds = new Dictionary<WeaponType, float>
		{
			{
				(WeaponType)0,
				1.251f
			},
			{
				(WeaponType)1,
				1.399f
			},
			{
				(WeaponType)2,
				1.629f
			},
			{
				(WeaponType)51,
				1.71f
			},
			{
				(WeaponType)52,
				1.667f
			},
			{
				(WeaponType)53,
				2.036f
			},
			{
				(WeaponType)54,
				1.499f
			},
			{
				(WeaponType)50,
				1.612f
			}
		};

		public static Dictionary<WeaponType, float> HeavyImpactModifiers = new Dictionary<WeaponType, float>
		{
			{
				(WeaponType)0,
				1.3f
			},
			{
				(WeaponType)1,
				1.3f
			},
			{
				(WeaponType)2,
				2.5f
			},
			{
				(WeaponType)51,
				1.5f
			},
			{
				(WeaponType)52,
				1.3f
			},
			{
				(WeaponType)53,
				2f
			},
			{
				(WeaponType)54,
				1.2f
			},
			{
				(WeaponType)50,
				1.3f
			}
		};
	}
	public class TinyTagManager
	{
		public static Tag GetOrMakeTag(string name)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: 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_0077: 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_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			Tag val = ((IEnumerable<Tag>)TagSourceManager.Instance.DbTags).FirstOrDefault((Func<Tag, bool>)((Tag x) => x.TagName == name));
			if (val == Tag.None)
			{
				((Tag)(ref val))..ctor(TagSourceManager.TagRoot, name);
				((Tag)(ref val)).SetTagType((TagTypes)0);
				TagSourceManager.Instance.DbTags.Add(val);
				TagSourceManager.Instance.RefreshTags(true);
				return val;
			}
			return val;
		}

		public static string[] GetOrMakeTags(string[] names)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			foreach (string name in names)
			{
				GetOrMakeTag(name);
			}
			return names;
		}

		public static string[] GetSafeTags(string[] tags)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			List<string> list = new List<string>();
			foreach (string tag in tags)
			{
				((IEnumerable<Tag>)TagSourceManager.Instance.DbTags).FirstOrDefault((Func<Tag, bool>)((Tag x) => x.TagName == tag || ((Tag)(ref x)).UID == UID.op_Implicit(tag)));
				if (true)
				{
					list.Add(tag);
				}
			}
			return list.ToArray();
		}
	}
	public class TinyUIDManager
	{
		public static UID MakeUID(string name, string modGUID, string category)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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)
			if (modGUID == null || name == null || category == null)
			{
				Debug.LogError((object)$"TinyUIDManager.MakeUID({name}, {modGUID}, {category} returned a random UID. This will cause trouble in multiplayer!");
				return default(UID);
			}
			return new UID((modGUID + "." + category + "." + name).Replace(" ", "").ToLower());
		}
	}
	[BepInPlugin("com.ehaugw.tinyhelper", "Tiny Helper", "4.5.0")]
	public class TinyHelper : BaseUnityPlugin
	{
		public delegate void DescriptionModifier(Item item, ref string description);

		[HarmonyPatch(typeof(ResourcesPrefabManager), "Load")]
		public class ResourcesPrefabManager_Load
		{
			[HarmonyPostfix]
			public static void Postfix()
			{
				ResourcesPrefabManager instance = ResourcesPrefabManager.Instance;
				if (instance != null && instance.Loaded)
				{
					TinyHelper.OnPrefabLoaded();
				}
			}
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		public class Item_Description
		{
			[HarmonyPostfix]
			public static void Postfix(Item __instance, ref string __result)
			{
				OnDescriptionModified(__instance, ref __result);
			}
		}

		public const string GUID = "com.ehaugw.tinyhelper";

		public const string VERSION = "4.5.0";

		public const string NAME = "Tiny Helper";

		public static DescriptionModifier OnDescriptionModified;

		public static TinyHelper Instance;

		private static int tinyHelperPrintedMessages;

		public static string PLUGIN_ROOT_PATH => typeof(TinyHelper).Assembly.Location + "\\..\\..\\";

		public static event Action OnPrefabLoaded;

		internal void Awake()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			Instance = this;
			GameObject val = new GameObject("TinyHelperRPC");
			Object.DontDestroyOnLoad((Object)(object)val);
			val.AddComponent<TinyHelperRPCManager>();
			Harmony val2 = new Harmony("com.ehaugw.tinyhelper");
			val2.PatchAll();
		}

		public static void TinyHelperPrint(string str)
		{
			Debug.Log((object)("TinyHelper #" + tinyHelperPrintedMessages++ + ": " + str));
		}

		static TinyHelper()
		{
			TinyHelper.OnPrefabLoaded = delegate
			{
			};
			OnDescriptionModified = delegate
			{
			};
			tinyHelperPrintedMessages = 0;
		}
	}
	public class DelayedTask
	{
		public static Task GetTask(int milliseconds)
		{
			TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
			new Timer(delegate
			{
				tcs.SetResult(null);
			}).Change(milliseconds, -1);
			return tcs.Task;
		}
	}
	public class TinyEffectManager
	{
		public static StatusEffect MakeStatusEffectPrefab(string effectName, string familyName, string description, float lifespan, float refreshRate, StackBehaviors stackBehavior, string targetStatusName, bool isMalusEffect, string tagID = null, UID? uid = null, string modGUID = null, string iconFileName = null, string displayName = null, string rootPath = null)
		{
			//IL_001d: 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_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Expected O, but got Unknown
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Expected O, but got Unknown
			//IL_0194: Expected O, but got Unknown
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0238: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Expected O, but got Unknown
			Dictionary<string, StatusEffect> dictionary = At.GetValue(typeof(ResourcesPrefabManager), null, "STATUSEFFECT_PREFABS") as Dictionary<string, StatusEffect>;
			StatusEffectFamily val = MakeStatusEffectFamiliy(familyName, stackBehavior, -1, (LengthTypes)0);
			GameObject val2 = TinyGameObjectManager.InstantiateClone(((Component)dictionary[targetStatusName]).gameObject, effectName, setActive: false, dontDestroyOnLoad: true);
			StatusEffect obj = val2.GetComponent<StatusEffect>() ?? val2.AddComponent<StatusEffect>();
			StatusEffect val3 = obj;
			dictionary[effectName] = obj;
			StatusEffect val4 = val3;
			At.SetValue(effectName, typeof(StatusEffect), val4, "m_identifierName");
			At.SetValue<StatusEffectFamily>(val, typeof(StatusEffect), val4, "m_bindFamily");
			At.SetValue(displayName ?? effectName, typeof(StatusEffect), val4, "m_nameLocKey");
			At.SetValue(description, typeof(StatusEffect), val4, "m_descriptionLocKey");
			val4.RefreshRate = refreshRate;
			val4.IsMalusEffect = isMalusEffect;
			At.SetValue<EffectSignatureModes>((EffectSignatureModes)1, typeof(StatusEffect), val4, "m_effectSignatureMode");
			At.SetValue<FamilyModes>((FamilyModes)0, typeof(StatusEffect), val4, "m_familyMode");
			val4.RequiredStatus = null;
			val4.RemoveRequiredStatus = false;
			if (iconFileName != null)
			{
				val4.OverrideIcon = CustomTexture.MakeSprite(CustomTexture.LoadTexture(iconFileName, 0, linear: false, (FilterMode)0, null, rootPath), CustomTexture.SpriteBorderTypes.None);
			}
			TagSourceSelector value = ((tagID != null) ? new TagSourceSelector(TagSourceManager.Instance.GetTag(UID.op_Implicit(tagID))) : new TagSourceSelector());
			At.SetValue<TagSourceSelector>(value, typeof(StatusEffect), val4, "m_effectType");
			StatusData val5 = new StatusData(val4.StatusData);
			StatusData val6 = val5;
			val4.StatusData = val5;
			StatusData val7 = val6;
			val7.LifeSpan = lifespan;
			List<StatusData> list = At.GetValue(typeof(StatusEffect), val4, "m_statusStack") as List<StatusData>;
			list[0] = val7;
			Object.Destroy((Object)(object)((Component)val2.GetComponentInChildren<EffectSignature>()).gameObject);
			EffectSignature val8 = TinyGameObjectManager.MakeFreshObject("Signature", setActive: true, dontDestroyOnLoad: true).AddComponent<EffectSignature>();
			((Object)val8).name = "Signature";
			val8.SignatureUID = (UID)(((??)uid) ?? TinyUIDManager.MakeUID(effectName, modGUID, "Status Effect"));
			EffectSignature effectSignature = (val7.EffectSignature = val8);
			val.EffectSignature = effectSignature;
			StatusEffectFamilySelector val10 = new StatusEffectFamilySelector();
			((UidSelector<StatusEffectFamily>)(object)val10).Set(val);
			At.SetValue<StatusEffectFamilySelector>(val10, typeof(StatusEffect), val4, "m_stackingFamily");
			return val4;
		}

		public static StatusEffectFamily MakeStatusEffectFamiliy(string familyName, StackBehaviors stackBehavior, int maxStackCount, LengthTypes lengthType, UID? uid = null, string modGUID = null)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0031: 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_0061: 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_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			StatusEffectFamily val = new StatusEffectFamily();
			uid = (UID)(((??)uid) ?? ((modGUID != null) ? TinyUIDManager.MakeUID(familyName, modGUID, "Status Effect Family") : UID.Generate()));
			At.SetValue<UID>(uid.Value, typeof(StatusEffectFamily), val, "m_uid");
			val.Name = familyName;
			val.StackBehavior = stackBehavior;
			val.MaxStackCount = maxStackCount;
			val.LengthType = lengthType;
			return val;
		}

		public static void SetNameAndDesc(EffectPreset imbueEffect, string name, string desc)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Expected O, but got Unknown
			ItemLocalization value = new ItemLocalization(name, desc);
			if (At.GetValue(typeof(LocalizationManager), LocalizationManager.Instance, "m_itemLocalization") is Dictionary<int, ItemLocalization> dictionary)
			{
				if (dictionary.ContainsKey(imbueEffect.PresetID))
				{
					dictionary[imbueEffect.PresetID] = value;
				}
				else
				{
					dictionary.Add(imbueEffect.PresetID, value);
				}
			}
		}

		public static AddStatusEffectBuildUp MakeStatusEffectBuildup(Transform effectTransform, string statusEffectName, float buildup)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			AddStatusEffectBuildUp val = ((Component)effectTransform).gameObject.AddComponent<AddStatusEffectBuildUp>();
			val.BuildUpValue = buildup;
			val.Status = ResourcesPrefabManager.Instance.GetStatusEffectPrefab(statusEffectName);
			((Effect)val).OverrideEffectCategory = (EffectCategories)4;
			return val;
		}

		public static AddStatusEffect MakeStatusEffectChance(Transform effectTransform, string statusEffectName, int chance)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			AddStatusEffect val = ((Component)effectTransform).gameObject.AddComponent<AddStatusEffect>();
			val.SetChanceToContract(chance);
			val.Status = ResourcesPrefabManager.Instance.GetStatusEffectPrefab(statusEffectName);
			((Effect)val).OverrideEffectCategory = (EffectCategories)4;
			return val;
		}

		public static WeaponDamage MakeWeaponDamage(Transform effectTransform, float baseDamage, float damageScaling, Types damageType, float knockback)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			WeaponDamage val = ((Component)effectTransform).gameObject.AddComponent<WeaponDamage>();
			val.WeaponDamageMult = 1f + damageScaling;
			val.OverrideDType = damageType;
			((PunctualDamage)val).Damages = (DamageType[])(object)new DamageType[1]
			{
				new DamageType(damageType, baseDamage)
			};
			((Effect)val).OverrideEffectCategory = (EffectCategories)4;
			((PunctualDamage)val).Knockback = knockback;
			return val;
		}

		public static WeaponDamage MakeDynamicWeaponDamage(Transform effectTransform, IDamageScaler damageScaler)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			DynamicWeaponDamage dynamicWeaponDamage = ((Component)effectTransform).gameObject.AddComponent<DynamicWeaponDamage>();
			((Effect)dynamicWeaponDamage).OverrideEffectCategory = (EffectCategories)4;
			dynamicWeaponDamage.DamageScaler = damageScaler;
			return (WeaponDamage)(object)dynamicWeaponDamage;
		}

		public static void MakeAbsorbHealth(Transform effectTransform, float absorbRatio)
		{
			AddAbsorbHealth obj = ((Component)effectTransform).gameObject.AddComponent<AddAbsorbHealth>();
			At.SetValue(absorbRatio, typeof(AddAbsorbHealth), obj, "m_healthRatio");
		}

		public static ImbueEffectPreset MakeImbuePreset(int imbueID, string name, string description, string iconFileName = null, int? visualEffectID = null, List<Skill> replaceOnSkills = null, string statusEffectName = null, int? chanceToContract = null, int? buildUp = null, float? scalingDamage = null, float? flatDamage = null, float? knockback = null, Types? damageType = null)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Expected O, but got Unknown
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Expected O, but got I4
			//IL_023b->IL023b: Incompatible stack types: O vs I4
			//IL_0234->IL023b: Incompatible stack types: I4 vs O
			//IL_0234->IL023b: Incompatible stack types: O vs I4
			Dictionary<int, EffectPreset> dictionary = (Dictionary<int, EffectPreset>)At.GetValue(typeof(ResourcesPrefabManager), null, "EFFECTPRESET_PREFABS");
			if (!dictionary.ContainsKey(imbueID))
			{
				GameObject val = new GameObject(imbueID + "_" + name.Replace(" ", ""));
				val.SetActive(true);
				Object.DontDestroyOnLoad((Object)(object)val);
				ImbueEffectPreset val2 = val.AddComponent<ImbueEffectPreset>();
				((Object)val2).name = imbueID + "_" + name.Replace(" ", "");
				At.SetValue(imbueID, typeof(EffectPreset), val2, "m_StatusEffectID");
				At.SetValue(name, typeof(ImbueEffectPreset), val2, "m_imbueNameKey");
				At.SetValue(description, typeof(ImbueEffectPreset), val2, "m_imbueDescKey");
				if (visualEffectID.HasValue)
				{
					val2.ImbueStatusIcon = ((ImbueEffectPreset)dictionary[visualEffectID.Value]).ImbueStatusIcon;
					val2.ImbueFX = ((ImbueEffectPreset)dictionary[visualEffectID.Value]).ImbueFX;
				}
				if (iconFileName != null)
				{
					val2.ImbueStatusIcon = CustomTexture.MakeSprite(CustomTexture.LoadTexture(iconFileName, 0, linear: false, (FilterMode)0), CustomTexture.SpriteBorderTypes.None);
				}
				SetNameAndDesc((EffectPreset)(object)val2, name, description);
				dictionary.Add(imbueID, (EffectPreset)(object)val2);
				if (statusEffectName != null && chanceToContract.GetValueOrDefault() > 0)
				{
					MakeStatusEffectChance(TinyGameObjectManager.GetOrMake(((Component)val2).transform, "Effects", setActive: true, dontDestroyOnLoad: true), statusEffectName, chanceToContract.GetValueOrDefault());
				}
				if (statusEffectName != null && buildUp.GetValueOrDefault() > 0)
				{
					MakeStatusEffectBuildup(TinyGameObjectManager.GetOrMake(((Component)val2).transform, "Effects", setActive: true, dontDestroyOnLoad: true), statusEffectName, buildUp.GetValueOrDefault());
				}
				if (scalingDamage.GetValueOrDefault() > 0f || flatDamage.GetValueOrDefault() > 0f || knockback.GetValueOrDefault() > 0f)
				{
					object obj = TinyGameObjectManager.GetOrMake(((Component)val2).transform, "Effects", setActive: true, dontDestroyOnLoad: true);
					float valueOrDefault = flatDamage.GetValueOrDefault();
					valueOrDefault = scalingDamage.GetValueOrDefault();
					Types? val3 = damageType;
					int num;
					if (val3.HasValue)
					{
						obj = val3.GetValueOrDefault();
						num = (int)obj;
					}
					else
					{
						num = 9;
						obj = num;
						num = (int)obj;
					}
					MakeWeaponDamage((Transform)(object)num, valueOrDefault, valueOrDefault, (Types)obj, knockback.GetValueOrDefault());
				}
				foreach (Skill item in replaceOnSkills ?? new List<Skill>())
				{
					if ((Object)(object)item != (Object)null)
					{
						((ImbueObject)((Component)item).GetComponentInChildren<ImbueWeapon>()).ImbuedEffect = val2;
					}
				}
				return val2;
			}
			return null;
		}

		public static EffectPreset GetEffectPreset(int effectID)
		{
			Dictionary<int, EffectPreset> dictionary = (Dictionary<int, EffectPreset>)At.GetValue(typeof(ResourcesPrefabManager), null, "EFFECTPRESET_PREFABS");
			if (dictionary.ContainsKey(effectID))
			{
				EffectPreset val = dictionary[effectID];
				if (val != null)
				{
					return val;
				}
			}
			return null;
		}

		public static void AddStatusEffectForDuration(Character character, string _statusIdentifier, float duration, Character source = null, float chance = 1f)
		{
			StatusEffect statusEffectPrefab = ResourcesPrefabManager.Instance.GetStatusEffectPrefab(_statusIdentifier);
			AddStatusEffectForDuration(character, statusEffectPrefab, duration, source, chance);
		}

		public static void AddStatusEffectForDuration(Character character, StatusEffect statusEffect, float duration, Character source = null, float chance = 1f)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			StatusEffectManager statusEffectMngr = character.StatusEffectMngr;
			if (statusEffectMngr != null)
			{
				StatusData statusData = statusEffect.StatusData;
				statusEffect.StatusData = new StatusData(statusData);
				statusEffect.StatusData.LifeSpan = duration;
				statusEffectMngr.AddStatusEffect(statusEffect, source);
				statusEffect.StatusData = statusData;
			}
		}

		public static void ChangeEffectPresetDamageTypeData(EffectPreset effect, Types originalType, Types newType)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: 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_006b: Unknown result type (might be due to invalid IL or missing references)
			PunctualDamage[] componentsInChildren = ((Component)effect).gameObject.GetComponentsInChildren<PunctualDamage>();
			foreach (PunctualDamage val in componentsInChildren)
			{
				WeaponDamage val2 = (WeaponDamage)(object)((val is WeaponDamage) ? val : null);
				if (val2 != null && val2.OverrideDType == originalType)
				{
					val2.OverrideDType = newType;
				}
				DamageType[] damages = val.Damages;
				foreach (DamageType val3 in damages)
				{
					if (val3.Type == originalType)
					{
						val3.Type = newType;
					}
				}
			}
		}
	}
	public class CasualStagger : Effect
	{
		protected override void ActivateLocally(Character _affectedCharacter, object[] _infos)
		{
			Stagger(_affectedCharacter);
		}

		public static void Stagger(Character character)
		{
			At.SetValue<HurtType>((HurtType)1, typeof(Character), character, "m_hurtType");
			character.Animator.SetTrigger("Knockback");
			character.ForceCancel(false, true);
			((MonoBehaviour)character).Invoke("DelayedForceCancel", 0.3f);
			if (Object.op_Implicit((Object)(object)character.CharacterUI))
			{
				character.CharacterUI.OnPlayerKnocked();
			}
		}
	}
	public class CooldownChangeWeaponDamage : WeaponDamage
	{
		public float ExecutionSetCooldown = -1f;

		public float HitKnockbackCooldown = -1f;

		protected override void ActivateLocally(Character _affectedCharacter, object[] _infos)
		{
			Item parentItem = ((Effect)this).ParentItem;
			Skill val = (Skill)(object)((parentItem is Skill) ? parentItem : null);
			if (val != null)
			{
				if (HitKnockbackCooldown != -1f && _affectedCharacter.IsInKnockback)
				{
					At.SetValue(HitKnockbackCooldown, typeof(Skill), val, "m_remainingCooldownTime");
				}
				bool isDead = _affectedCharacter.IsDead;
				((WeaponDamage)this).ActivateLocally(_affectedCharacter, _infos);
				if (!isDead && _affectedCharacter.IsDead && ExecutionSetCooldown != -1f)
				{
					At.SetValue(ExecutionSetCooldown, typeof(Skill), val, "m_remainingCooldownTime");
				}
			}
		}
	}
}
namespace TinyHelper.Interfaces
{
	public interface IDamageScaler
	{
		float GetWeaponDamageMult(WeaponDamage weaponDamage);

		Types GetOverrideDType(WeaponDamage weaponDamage);

		DamageType[] GetDamages(WeaponDamage weaponDamage);

		float GetKnockback(WeaponDamage weaponDamage);
	}
}
namespace TinyHelper.Effects
{
	public class DynamicWeaponDamage : WeaponDamage
	{
		public IDamageScaler DamageScaler = null;

		private void Recalculate()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			Console.WriteLine("recalculated");
			Debug.WriteLine("recalculated");
			base.WeaponDamageMult = DamageScaler.GetWeaponDamageMult((WeaponDamage)(object)this);
			base.OverrideDType = DamageScaler.GetOverrideDType((WeaponDamage)(object)this);
			((PunctualDamage)this).Damages = DamageScaler.GetDamages((WeaponDamage)(object)this);
			((PunctualDamage)this).Knockback = DamageScaler.GetKnockback((WeaponDamage)(object)this);
		}

		protected override void StartInit()
		{
			Recalculate();
			((WeaponDamage)this).StartInit();
		}

		public override Weapon BuildDamage(Character _targetCharacter, ref DamageList _list, ref float _knockback)
		{
			Recalculate();
			return ((WeaponDamage)this).BuildDamage(_targetCharacter, ref _list, ref _knockback);
		}

		protected override void BuildDamage(Weapon _weapon, Character _targetCharacter, bool _isSkillOrShield, ref DamageList _list, ref float _knockback)
		{
			Recalculate();
			((WeaponDamage)this).BuildDamage(_weapon, _targetCharacter, _isSkillOrShield, ref _list, ref _knockback);
		}

		protected override void ActivateLocally(Character _targetCharacter, object[] _infos)
		{
			Recalculate();
			((WeaponDamage)this).ActivateLocally(_targetCharacter, _infos);
		}

		protected override DamageList DealHit(Character _targetCharacter)
		{
			Recalculate();
			return ((WeaponDamage)this).DealHit(_targetCharacter);
		}

		public override float DamageMult(Character _targetCharacter, bool _isSkill)
		{
			Recalculate();
			return ((WeaponDamage)this).DamageMult(_targetCharacter, _isSkill);
		}

		public override float KnockbackMult(Character _targetCharacter, bool _isSkill)
		{
			Recalculate();
			return ((WeaponDamage)this).KnockbackMult(_targetCharacter, _isSkill);
		}
	}
	public class ShootBlastFromEffect : ShootBlast
	{
		public override void Setup(TargetingSystem _targetSystem, Transform _parent)
		{
			Character sourceCharacter = ((Effect)this).SourceCharacter;
			((Shooter)this).Setup(((sourceCharacter != null) ? sourceCharacter.TargetingSystem : null) ?? _targetSystem, _parent);
		}
	}
}