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;
using HolyDamageManager;
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 CustomWeaponBehaviour;

public class MaulShoveBehaviour
{
	public virtual bool Eligible(Weapon weapon)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		return ((Item)weapon).HasTag(CustomWeaponBehaviour.MaulShoveTag);
	}

	public virtual bool IsActive(Weapon weapon)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0009: Invalid comparison between Unknown and I4
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Invalid comparison between Unknown and I4
		return (int)weapon.Type != 53 && (int)BehaviourManager.GetCurrentAnimationType(weapon) == 53;
	}

	public bool IsMaulShoveMode(Weapon weapon)
	{
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		int result;
		if (Eligible(weapon) && ((Item)weapon).IsEquipped)
		{
			Character ownerCharacter = ((EffectSynchronizer)weapon).OwnerCharacter;
			if (!((Object)(object)((ownerCharacter != null) ? ownerCharacter.LeftHandEquipment : null) == (Object)null))
			{
				Character ownerCharacter2 = ((EffectSynchronizer)weapon).OwnerCharacter;
				Equipment val = ((ownerCharacter2 != null) ? ownerCharacter2.LeftHandEquipment : null);
				if (val == null || !((Item)val).HasTag(CustomWeaponBehaviour.HandsFreeTag))
				{
					result = (((Equipment)weapon).TwoHanded ? 1 : 0);
					goto IL_005b;
				}
			}
			result = 1;
		}
		else
		{
			result = 0;
		}
		goto IL_005b;
		IL_005b:
		return (byte)result != 0;
	}

	public void PostAffectDamage(ref Weapon weapon, DamageList original, ref DamageList result)
	{
		if (!IsMaulShoveMode(weapon))
		{
			return;
		}
		foreach (IBastardModifier iBastardModifier in CustomWeaponBehaviour.IBastardModifiers)
		{
			iBastardModifier.ApplyDamageModifier(weapon, original, ref result);
		}
	}

	public void PostAffectImpact(ref Weapon weapon, float original, ref float result)
	{
		if (!IsMaulShoveMode(weapon))
		{
			return;
		}
		foreach (IBastardModifier iBastardModifier in CustomWeaponBehaviour.IBastardModifiers)
		{
			iBastardModifier.ApplyImpactModifier(weapon, original, ref result);
		}
	}

	public void PostAffectSpeed(ref Weapon weapon, float original, ref float result)
	{
		if (!IsMaulShoveMode(weapon))
		{
			return;
		}
		foreach (IBastardModifier iBastardModifier in CustomWeaponBehaviour.IBastardModifiers)
		{
			iBastardModifier.ApplySpeedModifier(weapon, original, ref result);
		}
	}

	public void PostAffectStaminaCost(ref Weapon weapon, float original, ref float result)
	{
		if (!IsMaulShoveMode(weapon))
		{
			return;
		}
		foreach (IBastardModifier iBastardModifier in CustomWeaponBehaviour.IBastardModifiers)
		{
			iBastardModifier.ApplyStaminaModifier(weapon, original, ref result);
		}
	}
}
public class BastardBehaviour
{
	public static WeaponType? GetBastardType(WeaponType type)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		//IL_0004: Unknown result type (might be due to invalid IL or missing references)
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Expected I4, but got Unknown
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		return (int)type switch
		{
			1 => (WeaponType)52, 
			0 => (WeaponType)51, 
			2 => (WeaponType)53, 
			_ => type, 
		};
	}

	public virtual bool Eligible(Weapon weapon)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		return ((Item)weapon).HasTag(CustomWeaponBehaviour.BastardTag) && !((Equipment)weapon).TwoHanded;
	}

	public bool IsBastardMode(Weapon weapon)
	{
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		if (!Eligible(weapon) || !((Item)weapon).IsEquipped)
		{
			goto IL_0064;
		}
		Character ownerCharacter = ((EffectSynchronizer)weapon).OwnerCharacter;
		if (!((Object)(object)((ownerCharacter != null) ? ownerCharacter.LeftHandEquipment : null) == (Object)null))
		{
			Character ownerCharacter2 = ((EffectSynchronizer)weapon).OwnerCharacter;
			Equipment val = ((ownerCharacter2 != null) ? ownerCharacter2.LeftHandEquipment : null);
			if (val == null || !((Item)val).HasTag(CustomWeaponBehaviour.HandsFreeTag))
			{
				goto IL_0064;
			}
		}
		int result = ((!CustomWeaponBehaviour.Instance.maulShoveBehaviour.IsActive(weapon)) ? 1 : 0);
		goto IL_0065;
		IL_0065:
		return (byte)result != 0;
		IL_0064:
		result = 0;
		goto IL_0065;
	}

	public void PostAffectDamage(ref Weapon weapon, DamageList original, ref DamageList result)
	{
		if (!IsBastardMode(weapon))
		{
			return;
		}
		foreach (IBastardModifier iBastardModifier in CustomWeaponBehaviour.IBastardModifiers)
		{
			iBastardModifier.ApplyDamageModifier(weapon, original, ref result);
		}
	}

	public void PostAffectImpact(ref Weapon weapon, float original, ref float result)
	{
		if (!IsBastardMode(weapon))
		{
			return;
		}
		foreach (IBastardModifier iBastardModifier in CustomWeaponBehaviour.IBastardModifiers)
		{
			iBastardModifier.ApplyImpactModifier(weapon, original, ref result);
		}
	}

	public void PostAffectSpeed(ref Weapon weapon, float original, ref float result)
	{
		if (!IsBastardMode(weapon))
		{
			return;
		}
		foreach (IBastardModifier iBastardModifier in CustomWeaponBehaviour.IBastardModifiers)
		{
			iBastardModifier.ApplySpeedModifier(weapon, original, ref result);
		}
	}

	public void PostAffectStaminaCost(ref Weapon weapon, float original, ref float result)
	{
		if (!IsBastardMode(weapon))
		{
			return;
		}
		foreach (IBastardModifier iBastardModifier in CustomWeaponBehaviour.IBastardModifiers)
		{
			iBastardModifier.ApplyStaminaModifier(weapon, original, ref result);
		}
	}
}
public class AttackCancelByBlockBehaviour
{
	public bool IsBlockMode(Character character)
	{
		return Eligible(character);
	}

	public virtual bool Eligible(Character character)
	{
		return false;
	}
}
public class AttackCancelBySkillBehaviour
{
	public bool IsAttackCancelBySkillMode(Character character)
	{
		return Eligible(character);
	}

	public virtual bool Eligible(Character character)
	{
		return false;
	}
}
public class SpecialLeapBehaviour
{
	public virtual bool IsSpecialLeapMode(Weapon weapon)
	{
		//IL_000a: Unknown result type (might be due to invalid IL or missing references)
		return ((Item)weapon).IsEquipped && ((Item)weapon).HasTag(CustomWeaponBehaviour.SpecialLeapTag);
	}
}
public class HalfHandedBehaviour
{
	public bool IsHalfHandedMode(Weapon weapon)
	{
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		if (!Eligible(weapon) || !((Item)weapon).IsEquipped)
		{
			goto IL_005a;
		}
		Character ownerCharacter = ((EffectSynchronizer)weapon).OwnerCharacter;
		if (!((Object)(object)((ownerCharacter != null) ? ownerCharacter.LeftHandEquipment : null) == (Object)null))
		{
			Character ownerCharacter2 = ((EffectSynchronizer)weapon).OwnerCharacter;
			Equipment val = ((ownerCharacter2 != null) ? ownerCharacter2.LeftHandEquipment : null);
			if (val == null || !((Item)val).HasTag(CustomWeaponBehaviour.HandsFreeTag))
			{
				goto IL_005a;
			}
		}
		int result = ((!((Equipment)weapon).TwoHanded) ? 1 : 0);
		goto IL_005b;
		IL_005b:
		return (byte)result != 0;
		IL_005a:
		result = 0;
		goto IL_005b;
	}

	public virtual bool Eligible(Weapon weapon)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		return ((Item)weapon).HasTag(CustomWeaponBehaviour.HalfHandedTag);
	}
}
public class ParryBehaviour
{
	public virtual float GetParryWindow(Weapon weapon)
	{
		return 0.3f;
	}

	public virtual float GetParryWindUp(Weapon weapon)
	{
		return 0.1f;
	}

	public bool IsParryMode(Weapon weapon)
	{
		int result;
		if (((Item)weapon).IsEquipped && Eligible(weapon))
		{
			Character ownerCharacter = ((EffectSynchronizer)weapon).OwnerCharacter;
			result = (((Object)(object)((ownerCharacter != null) ? ownerCharacter.LeftHandEquipment : null) == (Object)null || OffhandEligible((weapon != null) ? ((EffectSynchronizer)weapon).OwnerCharacter : null)) ? 1 : 0);
		}
		else
		{
			result = 0;
		}
		return (byte)result != 0;
	}

	public virtual bool OffhandEligible(Character character)
	{
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: Invalid comparison between Unknown and I4
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		Equipment obj = ((character != null) ? character.LeftHandEquipment : null);
		Weapon val = (Weapon)(object)((obj is Weapon) ? obj : null);
		return val != null && ((int)val.Type != 100 || ((Item)val).HasTag(CustomWeaponBehaviour.BucklerTag));
	}

	public virtual bool Eligible(Weapon weapon)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		return ((Item)weapon).HasTag(CustomWeaponBehaviour.ParryTag);
	}

	public virtual bool DidSuccessfulParry(Weapon weapon)
	{
		int result;
		if (IsParryMode(weapon))
		{
			Character ownerCharacter = ((EffectSynchronizer)weapon).OwnerCharacter;
			if (ownerCharacter != null && ownerCharacter.Blocking && Time.time - (float)At.GetField<Character>(ownerCharacter, "m_blockTime") < GetParryWindow(weapon) && ownerCharacter.Blocking)
			{
				result = ((Time.time - (float)At.GetField<Character>(ownerCharacter, "m_blockTime") > GetParryWindUp(weapon)) ? 1 : 0);
				goto IL_0065;
			}
		}
		result = 0;
		goto IL_0065;
		IL_0065:
		return (byte)result != 0;
	}

	public virtual void DeliverParry(Character blocker, Character striker, Vector3 _hitDir, float impactDamage)
	{
		//IL_0025: 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)
		At.Invoke<Character>(striker, "StabilityHit", new object[4]
		{
			impactDamage / 2f,
			Vector3.Angle(((Component)striker).transform.forward, -_hitDir),
			false,
			blocker
		});
		CasualStagger.Stagger(striker);
	}
}
public class HolyBehaviour
{
	public virtual Types GetHolyDamageType()
	{
		//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_0009: Unknown result type (might be due to invalid IL or missing references)
		return HolyDamageManager.GetDamageType();
	}

	public virtual float GetHolyWeaponConvertionRate(Weapon weapon)
	{
		return 0.2f;
	}

	public bool IsHolyWeaponMode(Weapon weapon)
	{
		//IL_0055: 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)
		if (((Item)weapon).IsEquipped && Eligible(weapon) && weapon.Imbued)
		{
			Effect[] imbuedEffects = weapon.FirstImbue.ImbuedEffects;
			foreach (Effect val in imbuedEffects)
			{
				WeaponDamage val2 = (WeaponDamage)(object)((val is WeaponDamage) ? val : null);
				if (val2 != null && ((PunctualDamage)val2).Damages.Length != 0 && ((PunctualDamage)val2).Damages[0].Type == GetHolyDamageType())
				{
					return true;
				}
			}
		}
		return false;
	}

	public virtual bool Eligible(Weapon weapon)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		return ((Item)weapon).HasTag(CustomWeaponBehaviour.HolyWeaponTag);
	}

	public void PostAffectDamage(ref Weapon _weapon, DamageList original, ref DamageList _damageList)
	{
		//IL_0032: 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_0044: Expected O, but got Unknown
		if (IsHolyWeaponMode(_weapon))
		{
			float totalDamage = _damageList.TotalDamage;
			float holyWeaponConvertionRate = GetHolyWeaponConvertionRate(_weapon);
			_damageList *= 1f - holyWeaponConvertionRate;
			_damageList.Add(new DamageType(GetHolyDamageType(), totalDamage * holyWeaponConvertionRate));
		}
	}
}
public class FinesseBehaviour
{
	public bool IsFinesseMode(Weapon weapon)
	{
		return ((Item)weapon).IsEquipped && Eligible(weapon);
	}

	public virtual bool Eligible(Weapon weapon)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		return ((Item)weapon).HasTag(CustomWeaponBehaviour.FinesseTag);
	}
}
public class BehaviourManager
{
	public static WeaponType GetCurrentAnimationType(Weapon weapon)
	{
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_003f: Unknown result type (might be due to invalid IL or missing references)
		if (((Item)weapon).IsEquipped)
		{
			Character ownerCharacter = ((EffectSynchronizer)weapon).OwnerCharacter;
			Animator val = ((ownerCharacter != null) ? ownerCharacter.Animator : null);
			if (val != null)
			{
				return (WeaponType)val.GetInteger("WeaponType");
			}
		}
		return weapon.Type;
	}

	public static bool IsComboAttack(Character __instance, int _type, int _id)
	{
		return _type switch
		{
			0 => true, 
			1 => __instance.NextAtkAllowed == 2, 
			_ => false, 
		};
	}

	public static bool AdaptGrip(Character __instance, ref int _type, ref int _id)
	{
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_005c: Invalid comparison between Unknown and I4
		//IL_0060: Unknown result type (might be due to invalid IL or missing references)
		//IL_006a: Invalid comparison between Unknown and I4
		//IL_0081: Unknown result type (might be due to invalid IL or missing references)
		//IL_0087: Unknown result type (might be due to invalid IL or missing references)
		//IL_019e: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
		//IL_0204: Unknown result type (might be due to invalid IL or missing references)
		//IL_0212: Unknown result type (might be due to invalid IL or missing references)
		//IL_0234: Unknown result type (might be due to invalid IL or missing references)
		//IL_0220: Unknown result type (might be due to invalid IL or missing references)
		//IL_0226: Invalid comparison between Unknown and I4
		Weapon val = ((__instance != null) ? __instance.CurrentWeapon : null);
		if ((Object)(object)val == (Object)null)
		{
			return false;
		}
		if (_type == 2502 || _type == 2511)
		{
			object field = At.GetField<Character>(__instance, "m_lastUsedSkill");
			MeleeSkill val2 = (MeleeSkill)((field is MeleeSkill) ? field : null);
			if (val2 != null && ((int)((Item)val2).ActivateEffectAnimType == 502 || (int)((Item)val2).ActivateEffectAnimType == 511) && ((AttackSkill)val2).RequiredWeaponTypes[0] != val.Type)
			{
				CustomWeaponBehaviour.ChangeGrip(__instance, ((AttackSkill)val2).RequiredWeaponTypes[0]);
				return true;
			}
		}
		if (CustomWeaponBehaviour.Instance.finesseBehaviour.IsFinesseMode(val) && _type == 1 && !IsComboAttack(__instance, _type, _id))
		{
			CustomWeaponBehaviour.ChangeGrip(__instance, (WeaponType)1);
			return true;
		}
		if (CustomWeaponBehaviour.Instance.halfHandedBehaviour.IsHalfHandedMode(val) && _type == 1 && !IsComboAttack(__instance, _type, _id))
		{
			_type = 0;
			CustomWeaponBehaviour.ChangeGrip(__instance, (WeaponType)54);
			return true;
		}
		if (CustomWeaponBehaviour.Instance.maulShoveBehaviour.IsMaulShoveMode(val) && _type == 1 && !IsComboAttack(__instance, _type, _id))
		{
			CustomWeaponBehaviour.ChangeGrip(__instance, (WeaponType)53);
			return true;
		}
		if (CustomWeaponBehaviour.Instance.bastardBehaviour.IsBastardMode(val))
		{
			WeaponType? bastardType = BastardBehaviour.GetBastardType(val.Type);
			if (bastardType.HasValue)
			{
				WeaponType valueOrDefault = bastardType.GetValueOrDefault();
				if (true && Extensions.Contains(new int[3] { 0, 1, 2500 }, _type))
				{
					CustomWeaponBehaviour.ChangeGrip(__instance, valueOrDefault);
					Equipment val3 = ((__instance != null) ? __instance.LeftHandEquipment : null);
					if (val3 != null && ((Item)val3).HasTag(CustomWeaponBehaviour.HandsFreeTag) && ((Item)val3).HasTag(CustomWeaponBehaviour.LanternTag) && (int)val3.IKType == 1)
					{
						val3.IKType = (IKMode)0;
					}
					return true;
				}
			}
		}
		return false;
	}

	public static bool SpellHasAttackAnimation(Character character)
	{
		if (character.IsCasting && character.Animator.GetInteger("AttackID") < 2)
		{
			return true;
		}
		return false;
	}

	public static bool AttackHasSpellAnimation(Character character)
	{
		if (!character.IsCasting && character.Animator.GetInteger("AttackID") >= 2)
		{
			return true;
		}
		return false;
	}
}
public interface IBaseDamageModifier
{
	bool Eligible(Weapon weapon);

	void Apply(Weapon weapon, DamageList original, ref DamageList result);
}
public interface IBastardModifier
{
	void ApplyDamageModifier(Weapon weapon, DamageList original, ref DamageList modifier);

	void ApplyImpactModifier(Weapon weapon, float original, ref float modifier);

	void ApplySpeedModifier(Weapon weapon, float original, ref float result);

	void ApplyStaminaModifier(Weapon weapon, float original, ref float result);
}
public interface IMaulShoveModifier
{
	void ApplyDamageModifier(Weapon weapon, DamageList original, ref DamageList result);

	void ApplyImpactModifier(Weapon weapon, float original, ref float result);

	void ApplySpeedModifier(Weapon weapon, float original, ref float result);
}
public class CustomBehaviourFormulas
{
	public static void PostAffectSpeed(Weapon weapon, ref float result)
	{
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_0054: Unknown result type (might be due to invalid IL or missing references)
		//IL_006f: Unknown result type (might be due to invalid IL or missing references)
		//IL_007f: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)weapon == (Object)null))
		{
			float original = result;
			CustomWeaponBehaviour.Instance.bastardBehaviour.PostAffectSpeed(ref weapon, original, ref result);
			CustomWeaponBehaviour.Instance.maulShoveBehaviour.PostAffectSpeed(ref weapon, original, ref result);
			if (WeaponManager.Speeds.ContainsKey(weapon.Type) && WeaponManager.Speeds.ContainsKey(BehaviourManager.GetCurrentAnimationType(weapon)))
			{
				result *= WeaponManager.Speeds[BehaviourManager.GetCurrentAnimationType(weapon)] / WeaponManager.Speeds[weapon.Type];
			}
			if (result < 0f)
			{
				result = 0f;
			}
		}
	}

	public static void PostAffectDamage(ref Weapon _weapon, ref DamageList result)
	{
		DamageList original = result.Clone();
		foreach (IBaseDamageModifier iBaseDamageModifier in CustomWeaponBehaviour.IBaseDamageModifiers)
		{
			if (iBaseDamageModifier.Eligible(_weapon))
			{
				iBaseDamageModifier.Apply(_weapon, original, ref result);
			}
		}
		CustomWeaponBehaviour.Instance.maulShoveBehaviour.PostAffectDamage(ref _weapon, original, ref result);
		CustomWeaponBehaviour.Instance.bastardBehaviour.PostAffectDamage(ref _weapon, original, ref result);
		CustomWeaponBehaviour.Instance.holyBehaviour.PostAffectDamage(ref _weapon, original, ref result);
	}

	public static void PostAffectImpact(ref Weapon _weapon, ref float _impactDamage)
	{
		float original = _impactDamage;
		CustomWeaponBehaviour.Instance.maulShoveBehaviour.PostAffectImpact(ref _weapon, original, ref _impactDamage);
		CustomWeaponBehaviour.Instance.bastardBehaviour.PostAffectImpact(ref _weapon, original, ref _impactDamage);
		if (_impactDamage < 0f)
		{
			_impactDamage = 0f;
		}
	}

	public static void PostAffectStaminaCost(Weapon _weapon, ref float _staminaCost)
	{
		float original = _staminaCost;
		CustomWeaponBehaviour.Instance.bastardBehaviour.PostAffectStaminaCost(ref _weapon, original, ref _staminaCost);
		if (_staminaCost < 0f)
		{
			_staminaCost = 0f;
		}
	}
}
public class EnableHitDetection : Effect
{
	protected override void ActivateLocally(Character _affectedCharacter, object[] _infos)
	{
		Item parentItem = ((Effect)this).ParentItem;
		MeleeSkill val = (MeleeSkill)(object)((parentItem is MeleeSkill) ? parentItem : null);
		if (val != null && (Object)(object)val.MeleeHitDetector != (Object)null)
		{
			MeleeHitDetector val2 = ((_affectedCharacter != null) ? _affectedCharacter.SkillMeleeDetector : null);
			if (val2 != null)
			{
				val2.HitStarted(-1);
				return;
			}
		}
		Weapon obj = ((_affectedCharacter != null) ? _affectedCharacter.CurrentWeapon : null);
		MeleeWeapon val3 = (MeleeWeapon)(object)((obj is MeleeWeapon) ? obj : null);
		if (val3 != null)
		{
			((Weapon)val3).HitStarted(-1);
		}
	}
}
public class WeaponSkillAnimationSelector : Effect
{
	public WeaponType WeaponType;

	protected override void ActivateLocally(Character character, object[] _infos)
	{
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		CustomWeaponBehaviour.ChangeGrip(character, WeaponType);
	}

	public static void SetCustomAttackAnimation(Skill skill, WeaponType weaponType)
	{
		//IL_0024: 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)
		Transform transform = TinyGameObjectManager.MakeFreshObject("ActivationEffects", true, true, ((Component)skill).transform).transform;
		((Component)transform).gameObject.AddComponent<WeaponSkillAnimationSelector>().WeaponType = weaponType;
	}
}
[HarmonyPatch(typeof(Skill), "HasAllRequirements")]
public class Skill_HasAllRequirements
{
	[HarmonyPrefix]
	public static void Prefix(Skill __instance, bool _tryingToActivate)
	{
		if (_tryingToActivate)
		{
			MeleeSkill val = (MeleeSkill)(object)((__instance is MeleeSkill) ? __instance : null);
			if (val != null && ((EffectSynchronizer)__instance).OwnerCharacter.NextAtkAllowed == 2 && CustomWeaponBehaviour.Instance.attackCancelBySkillBehaviour.IsAttackCancelBySkillMode(((EffectSynchronizer)__instance).OwnerCharacter) && ((Skill)val).HasAllRequirements(false))
			{
				((EffectSynchronizer)__instance).OwnerCharacter.ForceCancel(true, true);
				At.SetValue<bool>(true, typeof(Character), (object)((EffectSynchronizer)__instance).OwnerCharacter, "m_inLocomotion");
				At.SetValue<bool>(true, typeof(Character), (object)((EffectSynchronizer)__instance).OwnerCharacter, "m_nextIsLocomotion");
			}
		}
	}
}
[HarmonyPatch(typeof(Character), "BlockInput")]
public class Character_BlockInput
{
	[HarmonyPrefix]
	public static bool Prefix(Character __instance, ref bool _active)
	{
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: Invalid comparison between Unknown and I4
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0047: Invalid comparison between Unknown and I4
		if (__instance.IsAI)
		{
			return true;
		}
		if (!__instance.IsPhotonPlayerLocal || __instance.Sheathing || __instance.PreparingToSleep || __instance.Dodging || (int)__instance.CurrentSpellCast == 35 || (int)__instance.CurrentSpellCast == 900)
		{
			return true;
		}
		if (!_active || (__instance.InLocomotion && __instance.NextIsLocomotion))
		{
			return true;
		}
		if (__instance.ShieldEquipped || (Object)(object)__instance.CurrentWeapon == (Object)null || !CustomWeaponBehaviour.Instance.attackCancelByBlockBehaviour.IsBlockMode(__instance))
		{
			return true;
		}
		int num = (int)At.GetValue(typeof(Character), (object)__instance, "m_dodgeAllowedInAction");
		if (num > 0 && __instance.NextAtkAllowed > 0)
		{
			((MonoBehaviour)__instance).photonView.RPC("SendBlockStateTrivial", (PhotonTargets)0, new object[1] { true });
			__instance.StealthInput(false);
			return false;
		}
		return true;
	}
}
[HarmonyPatch(typeof(Character), "SendPerformAttackTrivial", new Type[]
{
	typeof(int),
	typeof(int)
})]
public class Character_SendPerformAttackTrivial
{
	[HarmonyPrefix]
	public static void Prefix(Character __instance, ref int _type, ref int _id)
	{
		BehaviourManager.AdaptGrip(__instance, ref _type, ref _id);
	}
}
[HarmonyPatch(typeof(Character), "HitEnded")]
public class Character_HitEnded
{
	[HarmonyPrefix]
	public static void Prefix(Character __instance, ref int _attackID)
	{
		if (_attackID != -2 && !__instance.IsCasting)
		{
			CustomWeaponBehaviour.ResetGrip(__instance);
		}
	}
}
[HarmonyPatch(typeof(Character), "StopLocomotionAction")]
public class Character_StopLocomotionAction
{
	[HarmonyPrefix]
	public static void Prefix(Character __instance)
	{
		CustomWeaponBehaviour.ResetGrip(__instance);
	}
}
[HarmonyPatch(typeof(Character), "ReceiveBlock", new Type[]
{
	typeof(MonoBehaviour),
	typeof(float),
	typeof(Vector3),
	typeof(float),
	typeof(float),
	typeof(Character),
	typeof(float)
})]
public class Character_ReceiveBlock
{
	[HarmonyPrefix]
	public static void Prefix(Character __instance, Character _dealerChar, Vector3 _hitDir, ref float _knockBack)
	{
		//IL_007a: Unknown result type (might be due to invalid IL or missing references)
		if (CustomWeaponBehaviour.Instance.parryBehaviour.DidSuccessfulParry(__instance.CurrentWeapon))
		{
			float num = _knockBack;
			float? obj;
			if (__instance == null)
			{
				obj = null;
			}
			else
			{
				Weapon currentWeapon = __instance.CurrentWeapon;
				obj = ((currentWeapon != null) ? new float?(currentWeapon.Impact) : null);
			}
			float? num2 = obj;
			_knockBack = num - num2.GetValueOrDefault();
			if (_knockBack < 0f)
			{
				_knockBack = 0f;
			}
			ParryBehaviour parryBehaviour = CustomWeaponBehaviour.Instance.parryBehaviour;
			float? obj2;
			if (__instance == null)
			{
				obj2 = null;
			}
			else
			{
				Weapon currentWeapon2 = __instance.CurrentWeapon;
				obj2 = ((currentWeapon2 != null) ? new float?(currentWeapon2.Impact) : null);
			}
			num2 = obj2;
			parryBehaviour.DeliverParry(__instance, _dealerChar, _hitDir, num2.GetValueOrDefault());
		}
	}
}
[HarmonyPatch(typeof(AttackSkill), "OwnerHasAllRequiredItems")]
public class AttackSkill_OwnerHasAllRequiredItemsMainHand
{
	[HarmonyPrefix]
	public static void Prefix(AttackSkill __instance, out List<WeaponType> __state)
	{
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00af: Unknown result type (might be due to invalid IL or missing references)
		__state = null;
		object obj;
		if (__instance == null)
		{
			obj = null;
		}
		else
		{
			Character ownerCharacter = ((EffectSynchronizer)__instance).OwnerCharacter;
			obj = ((ownerCharacter != null) ? ownerCharacter.CurrentWeapon : null);
		}
		Weapon val = (Weapon)obj;
		if (val == null || __instance.RequiredWeaponTypes == null)
		{
			return;
		}
		WeaponType? bastardType = BastardBehaviour.GetBastardType(val.Type);
		if (bastardType.HasValue)
		{
			WeaponType valueOrDefault = bastardType.GetValueOrDefault();
			if (__instance.RequiredWeaponTypes.Contains(valueOrDefault) && !__instance.RequiredWeaponTypes.Contains(val.Type) && CustomWeaponBehaviour.Instance.bastardBehaviour.IsBastardMode(val))
			{
				__state = __instance.RequiredWeaponTypes;
				__instance.RequiredWeaponTypes = new List<WeaponType>(__state);
				__instance.RequiredWeaponTypes.Add(val.Type);
			}
		}
	}

	public static void Postfix(AttackSkill __instance, List<WeaponType> __state)
	{
		if (__state != null)
		{
			__instance.RequiredWeaponTypes = __state;
		}
	}
}
[HarmonyPatch(typeof(AttackSkill), "OwnerHasAllRequiredItems")]
public class AttackSkill_OwnerHasAllRequiredItemsOffHand
{
	[HarmonyPrefix]
	public static void Prefix(AttackSkill __instance, out Tuple<List<WeaponType>, Equipment> __state)
	{
		//IL_0048: 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)
		__state = null;
		Character val = ((__instance != null) ? ((EffectSynchronizer)__instance).OwnerCharacter : null);
		if (val != null)
		{
			Weapon leftHandWeapon = val.LeftHandWeapon;
			if (leftHandWeapon != null && __instance.RequiredOffHandTypes != null && __instance.RequiredOffHandTypes.Contains((WeaponType)30) && ((Item)leftHandWeapon).HasTag(CustomWeaponBehaviour.PointyTag))
			{
				__state = new Tuple<List<WeaponType>, Equipment>(__instance.RequiredOffHandTypes, (Equipment)(object)(val.LeftHandWeapon ?? null));
				__instance.RequiredOffHandTypes = new List<WeaponType>(__state.Item1);
				__instance.RequiredOffHandTypes.Add(leftHandWeapon.Type);
				At.SetValue<Weapon>(leftHandWeapon, typeof(Character), (object)val, "m_leftHandEquipment");
			}
		}
	}

	public static void Postfix(AttackSkill __instance, Tuple<List<WeaponType>, Equipment> __state)
	{
		if (__state != null)
		{
			__instance.RequiredOffHandTypes = __state.Item1;
			At.SetValue<Equipment>(__state.Item2, typeof(Character), (object)((__instance != null) ? ((EffectSynchronizer)__instance).OwnerCharacter : null), "m_leftHandEquipment");
		}
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class WeaponDamage_BuildDamage
{
	[HarmonyPrefix]
	public static void Prefix(WeaponDamage __instance, ref AttackSkill ___m_attackSkill, out List<WeaponType> __state)
	{
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		//IL_0065: Unknown result type (might be due to invalid IL or missing references)
		//IL_0075: Unknown result type (might be due to invalid IL or missing references)
		//IL_00af: Unknown result type (might be due to invalid IL or missing references)
		__state = null;
		AttackSkill obj = ___m_attackSkill;
		object obj2;
		if (obj == null)
		{
			obj2 = null;
		}
		else
		{
			Character ownerCharacter = ((EffectSynchronizer)obj).OwnerCharacter;
			obj2 = ((ownerCharacter != null) ? ownerCharacter.CurrentWeapon : null);
		}
		Weapon val = (Weapon)obj2;
		if (val == null || ___m_attackSkill.RequiredWeaponTypes == null)
		{
			return;
		}
		WeaponType? bastardType = BastardBehaviour.GetBastardType(val.Type);
		if (bastardType.HasValue)
		{
			WeaponType valueOrDefault = bastardType.GetValueOrDefault();
			if (true && ___m_attackSkill.RequiredWeaponTypes.Contains(valueOrDefault) && !___m_attackSkill.RequiredWeaponTypes.Contains(val.Type) && CustomWeaponBehaviour.Instance.bastardBehaviour.IsBastardMode(val))
			{
				__state = ___m_attackSkill.RequiredWeaponTypes;
				___m_attackSkill.RequiredWeaponTypes = new List<WeaponType>(__state) { val.Type };
			}
		}
	}

	public static void Postfix(AttackSkill ___m_attackSkill, List<WeaponType> __state)
	{
		if (__state != null && (Object)(object)___m_attackSkill != (Object)null)
		{
			___m_attackSkill.RequiredWeaponTypes = __state;
		}
	}
}
[HarmonyPatch(typeof(AttackSkill), "OwnerHasAllRequiredItems")]
public class AttackSkill_OwnerHasAllRequiredItemsFist
{
	[HarmonyPrefix]
	public static void Prefix(AttackSkill __instance, out Tuple<List<WeaponType>, Equipment> __state)
	{
		//IL_0048: 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)
		__state = null;
		Character val = ((__instance != null) ? ((EffectSynchronizer)__instance).OwnerCharacter : null);
		if (val != null)
		{
			Weapon currentWeapon = val.CurrentWeapon;
			if (currentWeapon != null && __instance.RequiredOffHandTypes != null && __instance.RequiredOffHandTypes.Contains((WeaponType)30) && ((Item)currentWeapon).HasTag(CustomWeaponBehaviour.PointyTag))
			{
				__state = new Tuple<List<WeaponType>, Equipment>(__instance.RequiredOffHandTypes, (Equipment)(object)(val.LeftHandWeapon ?? null));
				__instance.RequiredOffHandTypes = new List<WeaponType>(__state.Item1);
				__instance.RequiredOffHandTypes.Add(currentWeapon.Type);
				At.SetValue<Weapon>(currentWeapon, typeof(Character), (object)val, "m_leftHandEquipment");
			}
		}
	}

	public static void Postfix(AttackSkill __instance, Tuple<List<WeaponType>, Equipment> __state)
	{
		if (__state != null)
		{
			__instance.RequiredOffHandTypes = __state.Item1;
			At.SetValue<Equipment>(__state.Item2, typeof(Character), (object)((__instance != null) ? ((EffectSynchronizer)__instance).OwnerCharacter : null), "m_leftHandEquipment");
		}
	}
}
[HarmonyPatch(typeof(CharacterStats), "GetAmplifiedAttackSpeed")]
public class CharacterStats_GetAmplifiedAttackSpeed
{
	[HarmonyPostfix]
	public static void Postfix(CharacterStats __instance, ref float __result, ref Character ___m_character)
	{
		Character obj = ___m_character;
		Weapon val = ((obj != null) ? obj.CurrentWeapon : null);
		if (!((Object)(object)val == (Object)null))
		{
			CustomBehaviourFormulas.PostAffectSpeed(val, ref __result);
		}
	}
}
[HarmonyPatch(typeof(WeaponStats), "GetAttackStamCost")]
public class WeaponStats_GetAttackStamCost
{
	[HarmonyPostfix]
	public static void Postfix(WeaponStats __instance, Item ___m_item, ref float __result)
	{
		Weapon val = (Weapon)(object)((___m_item is Weapon) ? ___m_item : null);
		if (val != null)
		{
			CustomBehaviourFormulas.PostAffectStaminaCost(val, ref __result);
		}
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Weapon_BaseImpact
{
	[HarmonyPostfix]
	public static void Postfix(Weapon __instance, ref float __result)
	{
		CustomBehaviourFormulas.PostAffectImpact(ref __instance, ref __result);
	}
}
[HarmonyPatch(typeof(WeaponStats), "GetAttackImpact")]
public class WeaponStats_GetAttackImpact
{
	[HarmonyPostfix]
	public static void Postfix(WeaponStats __instance, int _attackID, ref float __result, Item ___m_item)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Expected O, but got Unknown
		//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_005d: Unknown result type (might be due to invalid IL or missing references)
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		//IL_006f: Unknown result type (might be due to invalid IL or missing references)
		Weapon val = (Weapon)___m_item;
		WeaponType val2 = val.Type;
		object obj;
		if (val == null)
		{
			obj = null;
		}
		else
		{
			Character ownerCharacter = ((EffectSynchronizer)val).OwnerCharacter;
			obj = ((ownerCharacter != null) ? ownerCharacter.Animator : null);
		}
		Animator val3 = (Animator)obj;
		if (val3 != null && UnityEngineExtensions.HasParameter(val3, "WeaponType"))
		{
			val2 = (WeaponType)val3.GetInteger("WeaponType");
		}
		float num = 1f;
		if (WeaponStatData.WeaponBaseDataDict.Keys.Contains(val2))
		{
			num = WeaponStatData.WeaponBaseDataDict[val2].ImpactMult[_attackID];
		}
		__result = val.Impact * num;
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Weapon_Damage
{
	[HarmonyPostfix]
	public static void Postfix(Weapon __instance, ref DamageList __result)
	{
		__result = __result.Clone();
		CustomBehaviourFormulas.PostAffectDamage(ref __instance, ref __result);
	}
}
[HarmonyPatch(typeof(WeaponStats), "GetAttackDamage")]
public class WeaponStats_GetAttackDamage
{
	[HarmonyPostfix]
	public static void Postfix(WeaponStats __instance, int _attackID, ref IList<float> __result, Item ___m_item)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Expected O, but got Unknown
		//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_0069: Unknown result type (might be due to invalid IL or missing references)
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		//IL_007b: Unknown result type (might be due to invalid IL or missing references)
		Weapon val = (Weapon)___m_item;
		WeaponType val2 = val.Type;
		object obj;
		if (val == null)
		{
			obj = null;
		}
		else
		{
			Character ownerCharacter = ((EffectSynchronizer)val).OwnerCharacter;
			obj = ((ownerCharacter != null) ? ownerCharacter.Animator : null);
		}
		Animator val3 = (Animator)obj;
		if (val3 != null && UnityEngineExtensions.HasParameter(val3, "WeaponType"))
		{
			val2 = (WeaponType)val3.GetInteger("WeaponType");
		}
		float[] array = new float[5] { 1f, 1f, 1f, 1f, 1f };
		if (WeaponStatData.WeaponBaseDataDict.Keys.Contains(val2))
		{
			array = WeaponStatData.WeaponBaseDataDict[val2].DamageMult;
		}
		if (_attackID < 0 || _attackID >= array.Length)
		{
			_attackID = 0;
		}
		DamageList damage = val.Damage;
		for (int i = 0; i < damage.Count && i < __result.Count; i++)
		{
			__result[i] = damage[i].Damage * array[_attackID];
		}
	}
}
public class WeaponStatData
{
	public static Dictionary<WeaponType, WeaponStatData> WeaponBaseDataDict = new Dictionary<WeaponType, WeaponStatData>
	{
		{
			(WeaponType)0,
			new WeaponStatData
			{
				DamageMult = new float[5] { 1f, 1f, 1.495f, 1.265f, 1.265f },
				ImpactMult = new float[5] { 1f, 1f, 1.3f, 1.1f, 1.1f },
				StamMult = new float[5] { 1f, 1f, 1.2f, 1.1f, 1.1f }
			}
		},
		{
			(WeaponType)51,
			new WeaponStatData
			{
				DamageMult = new float[5] { 1f, 1f, 1.5f, 1.265f, 1.265f },
				ImpactMult = new float[5] { 1f, 1f, 1.5f, 1.1f, 1.1f },
				StamMult = new float[5] { 1f, 1f, 1.3f, 1.1f, 1.1f }
			}
		},
		{
			(WeaponType)1,
			new WeaponStatData
			{
				DamageMult = new float[5] { 1f, 1f, 1.3f, 1.3f, 1.3f },
				ImpactMult = new float[5] { 1f, 1f, 1.3f, 1.3f, 1.3f },
				StamMult = new float[5] { 1f, 1f, 1.2f, 1.2f, 1.2f }
			}
		},
		{
			(WeaponType)52,
			new WeaponStatData
			{
				DamageMult = new float[5] { 1f, 1f, 1.3f, 1.3f, 1.3f },
				ImpactMult = new float[5] { 1f, 1f, 1.3f, 1.3f, 1.3f },
				StamMult = new float[5] { 1f, 1f, 1.375f, 1.375f, 1.35f }
			}
		},
		{
			(WeaponType)2,
			new WeaponStatData
			{
				DamageMult = new float[5] { 1f, 1f, 1.3f, 1.3f, 1.3f },
				ImpactMult = new float[5] { 1f, 1f, 2.5f, 1.3f, 1.3f },
				StamMult = new float[5] { 1f, 1f, 1.3f, 1.3f, 1.3f }
			}
		},
		{
			(WeaponType)53,
			new WeaponStatData
			{
				DamageMult = new float[5] { 1f, 1f, 0.75f, 1.4f, 1.4f },
				ImpactMult = new float[5] { 1f, 1f, 2f, 1.4f, 1.4f },
				StamMult = new float[5] { 1f, 1f, 1.2f, 1.2f, 1.2f }
			}
		},
		{
			(WeaponType)50,
			new WeaponStatData
			{
				DamageMult = new float[5] { 1f, 1f, 1.3f, 1.3f, 1.7f },
				ImpactMult = new float[5] { 1f, 1f, 1.3f, 1.3f, 1.7f },
				StamMult = new float[5] { 1f, 1f, 1.25f, 1.25f, 1.75f }
			}
		},
		{
			(WeaponType)54,
			new WeaponStatData
			{
				DamageMult = new float[5] { 1f, 1f, 1.4f, 1.3f, 1.2f },
				ImpactMult = new float[5] { 1f, 1f, 1.2f, 1.2f, 1.1f },
				StamMult = new float[5] { 1f, 1f, 1.25f, 1.25f, 1.25f }
			}
		},
		{
			(WeaponType)55,
			new WeaponStatData
			{
				DamageMult = new float[5] { 1f, 1f, 1.3f, 1.3f, 1.3f },
				ImpactMult = new float[5] { 1f, 1f, 1.3f, 1.3f, 1.3f },
				StamMult = new float[5] { 1f, 1f, 1.3f, 1.2f, 1.2f }
			}
		}
	};

	public float[] DamageMult;

	public float[] ImpactMult;

	public float[] StamMult;
}
[BepInPlugin("com.ehaugw.customweaponbehaviour", "Custom Weapon Behaviour", "3.1.3")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency("com.ehaugw.holydamagemanager", "1.0.0")]
[BepInDependency("com.ehaugw.tinyhelper", "4.3.4")]
public class CustomWeaponBehaviour : BaseUnityPlugin
{
	public const string GUID = "com.ehaugw.customweaponbehaviour";

	public const string VERSION = "3.1.3";

	public const string NAME = "Custom Weapon Behaviour";

	public static CustomWeaponBehaviour Instance;

	public static Tag BastardTag;

	public static Tag FinesseTag;

	public static Tag HolyWeaponTag;

	public static Tag HalfHandedTag;

	public static Tag SpecialLeapTag;

	public static Tag ParryTag;

	public static Tag BucklerTag;

	public static Tag WandTag;

	public static Tag HandsFreeTag;

	public static Tag LanternTag;

	public static Tag MaulShoveTag;

	public static Tag PointyTag;

	public BastardBehaviour bastardBehaviour = new BastardBehaviour();

	public MaulShoveBehaviour maulShoveBehaviour = new MaulShoveBehaviour();

	public FinesseBehaviour finesseBehaviour = new FinesseBehaviour();

	public HalfHandedBehaviour halfHandedBehaviour = new HalfHandedBehaviour();

	public HolyBehaviour holyBehaviour = new HolyBehaviour();

	public ParryBehaviour parryBehaviour = new ParryBehaviour();

	public AttackCancelByBlockBehaviour attackCancelByBlockBehaviour = new AttackCancelByBlockBehaviour();

	public AttackCancelBySkillBehaviour attackCancelBySkillBehaviour = new AttackCancelBySkillBehaviour();

	public static List<IBastardModifier> IBastardModifiers = new List<IBastardModifier>();

	public static List<IMaulShoveModifier> IMaulShoveModifiers = new List<IMaulShoveModifier>();

	public static List<IBaseDamageModifier> IBaseDamageModifiers = new List<IBaseDamageModifier>();

	internal void Awake()
	{
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Expected O, but got Unknown
		//IL_0069: Unknown result type (might be due to invalid IL or missing references)
		//IL_0073: Expected O, but got Unknown
		//IL_0073: Unknown result type (might be due to invalid IL or missing references)
		//IL_007d: Expected O, but got Unknown
		IBastardModifiers.Add(new BastardModifier());
		IMaulShoveModifiers.Add(new MaulShoveModifier());
		Instance = this;
		Harmony val = new Harmony("com.ehaugw.customweaponbehaviour");
		val.PatchAll();
		SL.BeforePacksLoaded += BeforePacksLoaded;
		SL.OnPacksLoaded += OnPacksLoaded;
		TinyHelper.OnDescriptionModified = (DescriptionModifier)Delegate.Combine((Delegate?)(object)TinyHelper.OnDescriptionModified, (Delegate?)new DescriptionModifier(CustomTagDescriptionModifier));
	}

	private void CustomTagDescriptionModifier(Item item, ref string description)
	{
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		//IL_0066: Unknown result type (might be due to invalid IL or missing references)
		//IL_008e: Unknown result type (might be due to invalid IL or missing references)
		string text = "";
		foreach (Tuple<Tag, string> item2 in new List<Tuple<Tag, string>>
		{
			new Tuple<Tag, string>(PointyTag, "Pointy"),
			new Tuple<Tag, string>(BastardTag, "Bastard"),
			new Tuple<Tag, string>(FinesseTag, "Finesse"),
			new Tuple<Tag, string>(HolyWeaponTag, "Holy"),
			new Tuple<Tag, string>(WandTag, "Wand")
		})
		{
			if (item.HasTag(item2.Item1))
			{
				text = text + ((text.Length > 0) ? ", " : "") + item2.Item2;
			}
		}
		if (text.Length > 0)
		{
			description = text + "\n\n" + description;
		}
	}

	private void BeforePacksLoaded()
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		//IL_0056: Unknown result type (might be due to invalid IL or missing references)
		//IL_0060: Unknown result type (might be due to invalid IL or missing references)
		//IL_0065: Unknown result type (might be due to invalid IL or missing references)
		//IL_006f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0074: Unknown result type (might be due to invalid IL or missing references)
		//IL_007e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_008d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0092: Unknown result type (might be due to invalid IL or missing references)
		//IL_009c: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
		PointyTag = TinyTagManager.GetOrMakeTag("Pointy");
		BastardTag = TinyTagManager.GetOrMakeTag("Bastard");
		FinesseTag = TinyTagManager.GetOrMakeTag("Finesse");
		HolyWeaponTag = TinyTagManager.GetOrMakeTag("Holy");
		ParryTag = TinyTagManager.GetOrMakeTag("Parry");
		BucklerTag = TinyTagManager.GetOrMakeTag("Buckler");
		HalfHandedTag = TinyTagManager.GetOrMakeTag("HalfHanded");
		SpecialLeapTag = TinyTagManager.GetOrMakeTag("SpecialLeap");
		WandTag = TinyTagManager.GetOrMakeTag("Wand");
		HandsFreeTag = TinyTagManager.GetOrMakeTag("HandsFreeTag");
		LanternTag = TinyTagManager.GetOrMakeTag("Lantern");
		MaulShoveTag = TinyTagManager.GetOrMakeTag("MaulShoveTag");
	}

	private void OnPacksLoaded()
	{
	}

	public static void ChangeGrip(Character character, WeaponType toMoveset)
	{
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Expected O, but got Unknown
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0033: Expected I4, but got Unknown
		((CharacterKnowledge)character.Inventory.SkillKnowledge).AddItem(new Item());
		if (character != null)
		{
			Animator animator = character.Animator;
			if (animator != null)
			{
				animator.SetInteger("WeaponType", (int)toMoveset);
			}
		}
	}

	public static void ResetGrip(Character character)
	{
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0037: Expected I4, but got Unknown
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_0056: Unknown result type (might be due to invalid IL or missing references)
		//IL_0074: Unknown result type (might be due to invalid IL or missing references)
		//IL_0063: Unknown result type (might be due to invalid IL or missing references)
		//IL_0069: Invalid comparison between Unknown and I4
		Weapon val = ((character != null) ? character.CurrentWeapon : null);
		if (val != null && character != null)
		{
			Animator animator = character.Animator;
			if (animator != null)
			{
				animator.SetInteger("WeaponType", (int)val.Type);
			}
		}
		Equipment val2 = ((character != null) ? character.LeftHandEquipment : null);
		if (val2 != null && ((Item)val2).HasTag(HandsFreeTag) && ((Item)val2).HasTag(LanternTag) && (int)val2.IKType == 0)
		{
			val2.IKType = (IKMode)1;
		}
	}
}
public class MaulShoveModifier : IMaulShoveModifier
{
	public void ApplyDamageModifier(Weapon weapon, DamageList original, ref DamageList result)
	{
		result += original * -0.25f;
	}

	public void ApplyImpactModifier(Weapon weapon, float original, ref float result)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_000c: Invalid comparison between Unknown and I4
		//IL_001a: 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_001f: Invalid comparison between Unknown and I4
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Invalid comparison between Unknown and I4
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Invalid comparison between Unknown and I4
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Invalid comparison between Unknown and I4
		WeaponType type = weapon.Type;
		WeaponType val = type;
		if ((int)val <= 2)
		{
			if ((int)val <= 1)
			{
				goto IL_002a;
			}
			if ((int)val != 2)
			{
				return;
			}
		}
		else
		{
			if (val - 51 <= 1)
			{
				goto IL_002a;
			}
			if ((int)val != 53)
			{
				return;
			}
		}
		result += original * 0.5f;
		return;
		IL_002a:
		result += original * 2f;
	}

	public void ApplySpeedModifier(Weapon weapon, float original, ref float result)
	{
		result += original * -0.2f;
	}
}
public class BastardModifier : IBastardModifier
{
	public void ApplyDamageModifier(Weapon weapon, DamageList original, ref DamageList result)
	{
		result += original * 0.1f;
	}

	public void ApplyImpactModifier(Weapon weapon, float original, ref float result)
	{
		result += original * 0.1f;
	}

	public void ApplySpeedModifier(Weapon weapon, float original, ref float result)
	{
		result += 0.1f;
	}

	public void ApplyStaminaModifier(Weapon weapon, float original, ref float stamina)
	{
		stamina += original * -0.4f;
	}
}