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 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 BaseDamageModifiers;

[BepInPlugin("com.ehaugw.basedamagemodifiers", "BaseDamageModifiers", "1.0.0")]
public class BaseDamageModifiers : BaseUnityPlugin
{
	public delegate void WeaponDamageModifier(Weapon weapon, DamageList original, ref DamageList result);

	public delegate void WeaponImpactModifier(Weapon weapon, float original, ref float result);

	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	public class Weapon_BaseImpact
	{
		[HarmonyPostfix]
		public static void Postfix(Weapon __instance, ref float __result)
		{
			float original = __result;
			WeaponImpactModifiers(__instance, original, 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))
			{
				float[] impactMult = WeaponStatData.WeaponBaseDataDict[val2].ImpactMult;
				if (_attackID < 0 || _attackID >= impactMult.Length)
				{
					_attackID = 0;
				}
				num = 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)
		{
			DamageList original = __result.Clone();
			__result = __result.Clone();
			WeaponDamageModifiers(__instance, original, 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 const string GUID = "com.ehaugw.basedamagemodifiers";

	public const string VERSION = "1.0.0";

	public const string NAME = "BaseDamageModifiers";

	public static WeaponDamageModifier WeaponDamageModifiers = delegate
	{
	};

	public static WeaponImpactModifier WeaponImpactModifiers = delegate
	{
	};

	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.basedamagemodifiers");
		val.PatchAll();
	}
}
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;
}

using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using HarmonyLib;
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 CustomGrip;

[BepInPlugin("com.ehaugw.customgrip", "CustomGrip", "1.0.0")]
public class CustomGrip : BaseUnityPlugin
{
	public const string GUID = "com.ehaugw.customgrip";

	public const string VERSION = "1.0.0";

	public const string NAME = "CustomGrip";

	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.customgrip");
		val.PatchAll();
	}

	public static void ChangeGrip(Character character, WeaponType toMoveset)
	{
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_001d: Expected I4, but got Unknown
		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
		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);
			}
		}
	}
}
[HarmonyPatch(typeof(Character), "HitEnded")]
public class Character_HitEnded
{
	[HarmonyPrefix]
	public static void Prefix(Character __instance, ref int _attackID)
	{
		if (_attackID != -2 && !__instance.IsCasting)
		{
			CustomGrip.ResetGrip(__instance);
		}
	}
}
[HarmonyPatch(typeof(Character), "StopLocomotionAction")]
public class Character_StopLocomotionAction
{
	[HarmonyPrefix]
	public static void Prefix(Character __instance)
	{
		CustomGrip.ResetGrip(__instance);
	}
}
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)
		CustomGrip.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;
	}
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BaseDamageModifiers;
using BepInEx;
using CustomGrip;
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 && IsMaulShoveMode(weapon);
	}

	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 (!IsActive(weapon))
		{
			return;
		}
		foreach (IMaulShoveModifier iMaulShoveModifier in CustomWeaponBehaviour.IMaulShoveModifiers)
		{
			iMaulShoveModifier.ApplyDamageModifier(weapon, original, ref result);
		}
	}

	public void PostAffectImpact(ref Weapon weapon, float original, ref float result)
	{
		if (!IsActive(weapon))
		{
			return;
		}
		foreach (IMaulShoveModifier iMaulShoveModifier in CustomWeaponBehaviour.IMaulShoveModifiers)
		{
			iMaulShoveModifier.ApplyImpactModifier(weapon, original, ref result);
		}
	}

	public void PostAffectSpeed(ref Weapon weapon, float original, ref float result)
	{
		if (!IsActive(weapon))
		{
			return;
		}
		foreach (IMaulShoveModifier iMaulShoveModifier in CustomWeaponBehaviour.IMaulShoveModifiers)
		{
			iMaulShoveModifier.ApplySpeedModifier(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)
		bool eligible = ((Item)weapon).HasTag(CustomWeaponBehaviour.BastardTag) && !((Equipment)weapon).TwoHanded && UnityEngineExtensions.FindAllInAllChildren(((Component)weapon).transform, "DisableBastardMoveset").Count() == 0;
		CustomWeaponBehaviour.Instance.BastardDisablers(weapon, ref eligible);
		return eligible;
	}

	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)
	{
		return true;
	}

	public virtual bool Eligible(Weapon weapon)
	{
		return true;
	}

	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)
			{
				CustomGrip.ChangeGrip(__instance, ((AttackSkill)val2).RequiredWeaponTypes[0]);
				return true;
			}
		}
		if (CustomWeaponBehaviour.Instance.finesseBehaviour.IsFinesseMode(val) && _type == 1 && !IsComboAttack(__instance, _type, _id))
		{
			CustomGrip.ChangeGrip(__instance, (WeaponType)1);
			return true;
		}
		if (CustomWeaponBehaviour.Instance.halfHandedBehaviour.IsHalfHandedMode(val) && _type == 1 && !IsComboAttack(__instance, _type, _id))
		{
			_type = 0;
			CustomGrip.ChangeGrip(__instance, (WeaponType)54);
			return true;
		}
		if (CustomWeaponBehaviour.Instance.maulShoveBehaviour.IsMaulShoveMode(val) && _type == 1 && !IsComboAttack(__instance, _type, _id))
		{
			CustomGrip.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))
				{
					CustomGrip.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 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_0084: Unknown result type (might be due to invalid IL or missing references)
		//IL_0094: 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)) && !CustomWeaponBehaviour.Instance.maulShoveBehaviour.IsActive(weapon))
			{
				result *= WeaponManager.Speeds[BehaviourManager.GetCurrentAnimationType(weapon)] / WeaponManager.Speeds[weapon.Type];
			}
			if (result < 0f)
			{
				result = 0f;
			}
		}
	}

	public static void PostAffectDamage(ref Weapon _weapon, DamageList original, ref DamageList 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, float original, ref float _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;
		}
	}
}
[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), "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);
		}
	}
}
[BepInPlugin("com.ehaugw.customweaponbehaviour", "Custom Weapon Behaviour", "4.0.3")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency("com.ehaugw.basedamagemodifiers", "1.0.0")]
[BepInDependency("com.ehaugw.holydamagemanager", "1.0.0")]
[BepInDependency("com.ehaugw.tinyhelper", "4.8.2")]
public class CustomWeaponBehaviour : BaseUnityPlugin
{
	public delegate void BastardDisabler(Weapon weapon, ref bool eligible);

	[Serializable]
	[CompilerGenerated]
	private sealed class <>c
	{
		public static readonly <>c <>9 = new <>c();

		public static WeaponDamageModifier <>9__28_0;

		public static WeaponImpactModifier <>9__28_1;

		public static BastardDisabler <>9__32_0;

		internal void <Awake>b__28_0(Weapon weapon, DamageList original, ref DamageList result)
		{
			CustomBehaviourFormulas.PostAffectDamage(ref weapon, original, ref result);
		}

		internal void <Awake>b__28_1(Weapon weapon, float original, ref float result)
		{
			CustomBehaviourFormulas.PostAffectImpact(ref weapon, original, ref result);
		}

		internal void <.ctor>b__32_0(Weapon weapon, ref bool eligible)
		{
		}
	}

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

	public const string VERSION = "4.0.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 BastardDisabler BastardDisablers = delegate
	{
	};

	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
		//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b0: Expected O, but got Unknown
		//IL_0096: Unknown result type (might be due to invalid IL or missing references)
		//IL_009b: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a1: Expected O, but got Unknown
		//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e3: Expected O, but got Unknown
		//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d4: 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));
		WeaponDamageModifier weaponDamageModifiers = BaseDamageModifiers.WeaponDamageModifiers;
		object obj = <>c.<>9__28_0;
		if (obj == null)
		{
			WeaponDamageModifier val2 = delegate(Weapon weapon, DamageList original, ref DamageList result)
			{
				CustomBehaviourFormulas.PostAffectDamage(ref weapon, original, ref result);
			};
			<>c.<>9__28_0 = val2;
			obj = (object)val2;
		}
		BaseDamageModifiers.WeaponDamageModifiers = (WeaponDamageModifier)Delegate.Combine((Delegate?)(object)weaponDamageModifiers, (Delegate?)obj);
		WeaponImpactModifier weaponImpactModifiers = BaseDamageModifiers.WeaponImpactModifiers;
		object obj2 = <>c.<>9__28_1;
		if (obj2 == null)
		{
			WeaponImpactModifier val3 = delegate(Weapon weapon, float original, ref float result)
			{
				CustomBehaviourFormulas.PostAffectImpact(ref weapon, original, ref result);
			};
			<>c.<>9__28_1 = val3;
			obj2 = (object)val3;
		}
		BaseDamageModifiers.WeaponImpactModifiers = (WeaponImpactModifier)Delegate.Combine((Delegate?)(object)weaponImpactModifiers, (Delegate?)obj2);
	}

	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 class MaulShoveModifier : IMaulShoveModifier
{
	public void ApplyDamageModifier(Weapon weapon, DamageList original, ref DamageList result)
	{
		result += original * -0.5f;
	}

	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_001c: Expected I4, but got Unknown
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0033: Expected I4, but got Unknown
		WeaponType type = weapon.Type;
		WeaponType val = type;
		switch ((int)val)
		{
		case 0:
			result += original * (WeaponManager.HeavyImpactModifiers[(WeaponType)53] / WeaponManager.HeavyImpactModifiers[(WeaponType)0] * 2f - 1f);
			return;
		case 1:
			result += original * (WeaponManager.HeavyImpactModifiers[(WeaponType)53] / WeaponManager.HeavyImpactModifiers[(WeaponType)1] * 1.9f - 1f);
			return;
		case 2:
			result += original * (WeaponManager.HeavyImpactModifiers[(WeaponType)53] / WeaponManager.HeavyImpactModifiers[(WeaponType)2] * 1.24f - 1f);
			return;
		}
		switch (val - 51)
		{
		case 0:
			result += original * (WeaponManager.HeavyImpactModifiers[(WeaponType)53] / WeaponManager.HeavyImpactModifiers[(WeaponType)51] * 1.18f - 1f);
			break;
		case 1:
			result += original * (WeaponManager.HeavyImpactModifiers[(WeaponType)53] / WeaponManager.HeavyImpactModifiers[(WeaponType)52] * 1.29f - 1f);
			break;
		case 2:
			break;
		}
	}

	public void ApplySpeedModifier(Weapon weapon, float original, ref float result)
	{
	}
}
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;
	}
}