using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Threading;
using AncientScepter;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using EmotesAPI;
using EntityStates;
using EntityStates.AI.Walker;
using Grumpy;
using HG;
using HG.BlendableTypes;
using JetBrains.Annotations;
using KinematicCharacterController;
using On.RoR2;
using On.RoR2.Items;
using R2API;
using R2API.Utils;
using RiskOfOptions;
using RiskOfOptions.OptionConfigs;
using RiskOfOptions.Options;
using RoR2;
using RoR2.Achievements;
using RoR2.Audio;
using RoR2.CameraModes;
using RoR2.CharacterAI;
using RoR2.ContentManagement;
using RoR2.Projectile;
using RoR2.Skills;
using RoR2.UI;
using SeamstressMod.Modules;
using SeamstressMod.Modules.Achievements;
using SeamstressMod.Modules.BaseStates;
using SeamstressMod.Modules.Characters;
using SeamstressMod.Seamstress;
using SeamstressMod.Seamstress.Components;
using SeamstressMod.Seamstress.Content;
using SeamstressMod.Seamstress.SkillStates;
using ThreeEyedGames;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.Events;
using UnityEngine.Networking;
using UnityEngine.Rendering;
using UnityEngine.Rendering.PostProcessing;

[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: CompilationRelaxations(8)]
[assembly: AssemblyCompany("SeamstressMod")]
[assembly: AssemblyProduct("SeamstressMod")]
[assembly: AssemblyTitle("SeamstressMod")]
[assembly: AssemblyInformationalVersion("1.0.0+3f946c233087ed2b9d8d1875101fcf5a337e9453")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace SeamstressMod
{
	internal static class Log
	{
		internal static ManualLogSource _logSource;

		internal static void Init(ManualLogSource logSource)
		{
			_logSource = logSource;
		}

		internal static void Debug(object data)
		{
			_logSource.LogDebug(data);
		}

		internal static void Error(object data)
		{
			_logSource.LogError(data);
		}

		internal static void ErrorAssetBundle(string assetName, string bundleName)
		{
			Error("failed to load asset, " + assetName + ", because it does not exist in asset bundle, " + bundleName);
		}

		internal static void Fatal(object data)
		{
			_logSource.LogFatal(data);
		}

		internal static void Info(object data)
		{
			_logSource.LogInfo(data);
		}

		internal static void Message(object data)
		{
			_logSource.LogMessage(data);
		}

		internal static void Warning(object data)
		{
			_logSource.LogWarning(data);
		}
	}
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("com.kenko.Seamstress", "Seamstress", "1.0.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class SeamstressPlugin : BaseUnityPlugin
	{
		public const string MODUID = "com.kenko.Seamstress";

		public const string MODNAME = "Seamstress";

		public const string MODVERSION = "1.0.0";

		public const string DEVELOPER_PREFIX = "KENKO";

		public static SeamstressPlugin instance;

		public static bool emotesInstalled => Chainloader.PluginInfos.ContainsKey("com.weliveinasociety.CustomEmotesAPI");

		public static bool scepterInstalled => Chainloader.PluginInfos.ContainsKey("com.DestroyedClone.AncientScepter");

		public static bool importanceInstalled => Chainloader.PluginInfos.ContainsKey("pseudopulse.EnemyImportance");

		public static bool riskOfOptionsInstalled => Chainloader.PluginInfos.ContainsKey("com.rune580.riskofoptions");

		private void Awake()
		{
			instance = this;
			Log.Init(((BaseUnityPlugin)this).Logger);
			Language.Init();
			new SeamstressSurvivor().Initialize();
			SeamstressConfig.EnableLiveUpdates();
			if (riskOfOptionsInstalled)
			{
				Config.InitializeOptions(CharacterBase<SeamstressSurvivor>.instance.prefabCharacterBody.portraitIcon);
			}
			new ContentPacks().Initialize();
		}

		private void Update()
		{
			SeamstressConfig.ApplyPendingChanges();
		}

		private void OnDestroy()
		{
			SeamstressConfig.DisableLiveUpdates();
		}
	}
}
namespace SeamstressMod.Seamstress
{
	public class SeamstressSurvivor : SurvivorBase<SeamstressSurvivor>
	{
		public static class ScepterCompat
		{
			public static void Initialize(AssetBundle assetBundle)
			{
				if (SeamstressPlugin.scepterInstalled)
				{
					InitializeScepter(assetBundle);
				}
			}

			private static void InitializeScepter(AssetBundle assetBundle)
			{
				//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_0077: Unknown result type (might be due to invalid IL or missing references)
				SkillDefInfo skillDefInfo = new SkillDefInfo();
				skillDefInfo.skillName = "FireScepterSeamstress";
				skillDefInfo.skillNameToken = "KENKO_SEAMSTRESS_SPECIAL_SCEPTER_NAME";
				skillDefInfo.skillDescriptionToken = "KENKO_SEAMSTRESS_SPECIAL_SCEPTER_DESCRIPTION";
				skillDefInfo.keywordTokens = new string[2]
				{
					Tokens.symbioticKeyword,
					Tokens.details2Keyword
				};
				skillDefInfo.skillIcon = assetBundle.LoadAsset<Sprite>("texSkewerScepterIcon");
				skillDefInfo.activationState = new SerializableEntityStateType(typeof(FireScissorsScepter));
				skillDefInfo.activationStateMachineName = "Weapon";
				skillDefInfo.interruptPriority = (InterruptPriority)1;
				skillDefInfo.baseRechargeInterval = 14f;
				skillDefInfo.baseMaxStock = 2;
				skillDefInfo.rechargeStock = 2;
				skillDefInfo.requiredStock = 1;
				skillDefInfo.stockToConsume = 1;
				skillDefInfo.resetCooldownTimerOnUse = false;
				skillDefInfo.fullRestockOnAssign = true;
				skillDefInfo.dontAllowPastMaxStocks = true;
				skillDefInfo.mustKeyPress = true;
				skillDefInfo.beginSkillCooldownOnSkillEnd = false;
				skillDefInfo.isCombatSkill = true;
				skillDefInfo.canceledFromSprinting = false;
				skillDefInfo.cancelSprintingOnActivation = true;
				skillDefInfo.forceSprintDuringState = false;
				SkillDef val = Skills.CreateSkillDef(skillDefInfo);
				ItemBase<AncientScepterItem>.instance.RegisterScepterSkill(val, "SeamstressBody", (SkillSlot)3, 0);
			}
		}

		public static class ImportanceCompat
		{
			public static void Importance()
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Expected O, but got Unknown
				if (!SeamstressPlugin.importanceInstalled)
				{
					BodyCatalog.Init += new hook_Init(BodyCatalog_Init);
				}
			}

			private static IEnumerator BodyCatalog_Init(orig_Init orig)
			{
				yield return orig.Invoke();
				foreach (GameObject body in BodyCatalog.allBodyPrefabs)
				{
					KinematicCharacterMotor motor = body.GetComponent<KinematicCharacterMotor>();
					if (Object.op_Implicit((Object)(object)motor))
					{
						motor.playerCharacter = true;
					}
				}
			}
		}

		public static class EmotesAPICompat
		{
			public static void Emotes()
			{
				GameObject val = SeamstressAssets.mainAssetBundle.LoadAsset<GameObject>("seamstress_emoteskeleton");
				CustomEmotesAPI.ImportArmature(characterPrefab, val, 0, true);
			}
		}

		public const string SEAMSTRESS_PREFIX = "KENKO_SEAMSTRESS_";

		internal static GameObject characterPrefab;

		internal static SkillDef parrySkillDef;

		public static SkillDef explodeSkillDef;

		public override string assetBundleName => "seamstressassets";

		public override string bodyName => "SeamstressBody";

		public override string masterName => "SeamstressMonsterMaster";

		public override string modelPrefabName => "mdlSeamstress";

		public override string displayPrefabName => "SeamstressDisplay";

		public override string survivorTokenPrefix => "KENKO_SEAMSTRESS_";

		internal static BodyIndex seamstressBodyIndex { get; private set; } = (BodyIndex)(-1);

		public override BodyInfo bodyInfo
		{
			get
			{
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: Unknown result type (might be due to invalid IL or missing references)
				//IL_008a: Unknown result type (might be due to invalid IL or missing references)
				BodyInfo bodyInfo = new BodyInfo();
				bodyInfo.bodyName = bodyName;
				bodyInfo.bodyNameToken = "KENKO_SEAMSTRESS_NAME";
				bodyInfo.subtitleNameToken = "KENKO_SEAMSTRESS_SUBTITLE";
				bodyInfo.characterPortrait = assetBundle.LoadAsset<Texture>("texSeamstressIcon");
				bodyInfo.bodyColor = new Color(31f / 51f, 11f / 51f, 11f / 51f);
				bodyInfo.sortPosition = 7f;
				bodyInfo.crosshair = CharacterAssets.LoadCrosshair("SimpleDot");
				bodyInfo.podPrefab = null;
				bodyInfo.initialStateType = new SerializableEntityStateType(typeof(SeamstressSpawnState));
				bodyInfo.damage = SeamstressConfig.damage.Value;
				bodyInfo.damageGrowth = SeamstressConfig.damageGrowth.Value * SeamstressConfig.damage.Value;
				bodyInfo.attackSpeed = SeamstressConfig.attackSpeed.Value;
				bodyInfo.attackSpeedGrowth = SeamstressConfig.attackSpeedGrowth.Value;
				bodyInfo.crit = SeamstressConfig.crit.Value;
				bodyInfo.critGrowth = SeamstressConfig.critGrowth.Value;
				bodyInfo.maxHealth = SeamstressConfig.maxHealth.Value;
				bodyInfo.healthGrowth = SeamstressConfig.healthGrowth.Value * SeamstressConfig.maxHealth.Value;
				bodyInfo.healthRegen = SeamstressConfig.healthRegen.Value;
				bodyInfo.regenGrowth = SeamstressConfig.regenGrowth.Value * SeamstressConfig.healthRegen.Value;
				bodyInfo.shield = SeamstressConfig.shield.Value;
				bodyInfo.shieldGrowth = SeamstressConfig.shieldGrowth.Value * SeamstressConfig.shield.Value;
				bodyInfo.armor = SeamstressConfig.armor.Value;
				bodyInfo.armorGrowth = SeamstressConfig.armorGrowth.Value * SeamstressConfig.armor.Value;
				bodyInfo.moveSpeed = SeamstressConfig.moveSpeed.Value;
				bodyInfo.moveSpeedGrowth = SeamstressConfig.moveSpeedGrowth.Value * SeamstressConfig.moveSpeed.Value;
				bodyInfo.jumpPower = SeamstressConfig.jumpPower.Value;
				bodyInfo.jumpPowerGrowth = SeamstressConfig.jumpPowerGrowth.Value * SeamstressConfig.jumpPower.Value;
				bodyInfo.acceleration = SeamstressConfig.acceleration.Value;
				bodyInfo.jumpCount = SeamstressConfig.jumpCount.Value;
				bodyInfo.autoCalculateLevelStats = SeamstressConfig.autoCalculateLevelStats.Value;
				return bodyInfo;
			}
		}

		public override CustomRendererInfo[] customRendererInfos => new CustomRendererInfo[5]
		{
			new CustomRendererInfo
			{
				childName = "Model"
			},
			new CustomRendererInfo
			{
				childName = "ScissorLModel"
			},
			new CustomRendererInfo
			{
				childName = "ScissorRModel"
			},
			new CustomRendererInfo
			{
				childName = "CrownModel"
			},
			new CustomRendererInfo
			{
				childName = "HeartModel"
			}
		};

		public override UnlockableDef characterUnlockableDef => SeamstressUnlockables.characterUnlockableDef;

		public override ItemDisplaysBase itemDisplays => new SeamstressItemDisplays();

		public override AssetBundle assetBundle { get; protected set; }

		public override GameObject bodyPrefab { get; protected set; }

		public override CharacterBody prefabCharacterBody { get; protected set; }

		public override GameObject characterModelObject { get; protected set; }

		public override CharacterModel prefabCharacterModel { get; protected set; }

		public override GameObject displayPrefab { get; protected set; }

		public override void Initialize()
		{
			base.Initialize();
		}

		public override void InitializeCharacter()
		{
			SeamstressConfig.Init();
			SeamstressUnlockables.Init();
			base.InitializeCharacter();
			SeamstressCrosshair.Init(assetBundle);
			DamageTypes.Init();
			SeamstressStates.Init();
			SeamstressTokens.Init();
			SeamstressAssets.Init(assetBundle);
			SeamstressBuffs.Init(assetBundle);
			SeamstressDots.Init();
			InitializeEntityStateMachines();
			InitializeSkills();
			InitializeSkins();
			InitializeCharacterMaster();
			AdditionalBodySetup();
			characterPrefab = bodyPrefab;
			AddHooks();
		}

		private void AdditionalBodySetup()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected O, but got Unknown
			//IL_004a: Expected O, but got Unknown
			//IL_0057: 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_0072: Expected O, but got Unknown
			//IL_0072: Expected O, but got Unknown
			AddHitboxes();
			AddSoundBank("RoR2/Base/Croco/CrocoBody.prefab");
			AddSoundBank("RoR2/Base/Bandit2/Bandit2Body.prefab");
			TempVisualEffectAPI.AddTemporaryVisualEffect(SeamstressAssets.sewnCdEffect, new EffectRadius(pee), new EffectCondition(tempAdd), "");
			TempVisualEffectAPI.AddTemporaryVisualEffect(SeamstressAssets.sewnEffect, new EffectRadius(pee), new EffectCondition(tempAdd2), "");
			bodyPrefab.AddComponent<SeamstressController>();
			bodyPrefab.AddComponent<ScissorsControllerComponent>();
			bodyPrefab.AddComponent<NeedleController>();
			bodyPrefab.AddComponent<Tracker>();
			bodyPrefab.AddComponent<InsatiableController>();
			bodyPrefab.AddComponent<SeamstressBlinkController>();
			bodyPrefab.AddComponent<SeamstressDamageScalingController>();
			static float pee(CharacterBody body)
			{
				return 2f * body.radius;
			}
			static bool tempAdd(CharacterBody body)
			{
				return body.HasBuff(SeamstressBuffs.ManipulatedCd);
			}
			static bool tempAdd2(CharacterBody body)
			{
				return body.HasBuff(SeamstressBuffs.Manipulated);
			}
		}

		private void AddSoundBank(string sourceBodyPath)
		{
			//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)
			AkBank component = Addressables.LoadAssetAsync<GameObject>((object)sourceBodyPath).WaitForCompletion().GetComponent<AkBank>();
			if (!Object.op_Implicit((Object)(object)component))
			{
				throw new InvalidOperationException("Missing soundbank component on " + sourceBodyPath + ".");
			}
			AkBank val = bodyPrefab.AddComponent<AkBank>();
			((AkTriggerHandler)val).triggerList = ((AkTriggerHandler)component).triggerList;
			val.data = component.data;
			((AkTriggerHandler)val).useOtherObject = false;
			val.decodeBank = false;
			val.overrideLoadSetting = false;
			val.loadAsynchronous = false;
			val.saveDecodedBank = false;
			val.unloadTriggerList = component.unloadTriggerList;
		}

		public void AddHitboxes()
		{
			Prefabs.SetupHitBoxGroup(characterModelObject, "Sword", "SwordHitbox");
			Prefabs.SetupHitBoxGroup(characterModelObject, "SwordBig", "SwordHitboxBig");
			Prefabs.SetupHitBoxGroup(characterModelObject, "Weave", "WeaveHitbox");
			Prefabs.SetupHitBoxGroup(characterModelObject, "WeaveBig", "WeaveHitboxBig");
			Prefabs.SetupHitBoxGroup(characterModelObject, "Right", "RightScissorHitbox");
			Prefabs.SetupHitBoxGroup(characterModelObject, "Left", "LeftScissorHitbox");
		}

		public override void InitializeEntityStateMachines()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			bodyPrefab.GetComponent<CharacterBody>().preferredInitialStateType = new SerializableEntityStateType(typeof(SeamstressSpawnState));
			EntityStateMachine[] components = bodyPrefab.GetComponents<EntityStateMachine>();
			foreach (EntityStateMachine val in components)
			{
				if (val.customName == "Body")
				{
					val.mainStateType = new SerializableEntityStateType(typeof(MainState));
				}
			}
			EntityStateMachine val2 = bodyPrefab.AddComponent<EntityStateMachine>();
			val2.initialStateType = new SerializableEntityStateType(typeof(SeamstressJump));
			val2.mainStateType = new SerializableEntityStateType(typeof(SeamstressJump));
			val2.customName = "Passive";
			Prefabs.AddEntityStateMachine(bodyPrefab, "Weapon");
			Prefabs.AddEntityStateMachine(bodyPrefab, "Weapon2");
		}

		public override void InitializeSkills()
		{
			bodyPrefab.AddComponent<SeamstressPassive>();
			Skills.CreateSkillFamilies(bodyPrefab);
			AddPassiveSkills();
			AddPrimarySkills();
			AddSecondarySkills();
			AddUtilitySkills();
			AddSpecialSkills();
			ScepterCompat.Initialize(assetBundle);
		}

		private void AddPassiveSkills()
		{
			//IL_0082: 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_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			SeamstressPassive component = bodyPrefab.GetComponent<SeamstressPassive>();
			SkillLocator component2 = bodyPrefab.GetComponent<SkillLocator>();
			component2.passiveSkill.enabled = false;
			component.blinkPassive = Skills.CreateSkillDef(new SkillDefInfo
			{
				skillName = "KENKO_SEAMSTRESS_PASSIVE_NAME",
				skillNameToken = "KENKO_SEAMSTRESS_PASSIVE_NAME",
				skillDescriptionToken = "KENKO_SEAMSTRESS_PASSIVE_DESCRIPTION",
				skillIcon = assetBundle.LoadAsset<Sprite>("texItHungersIcon"),
				keywordTokens = new string[1] { "KENKO_SEAMSTRESS_KEYWORD_PLANE_BOUND" },
				activationState = new SerializableEntityStateType(typeof(Idle)),
				activationStateMachineName = "",
				baseMaxStock = 1,
				baseRechargeInterval = 0f,
				beginSkillCooldownOnSkillEnd = false,
				canceledFromSprinting = false,
				forceSprintDuringState = false,
				fullRestockOnAssign = true,
				interruptPriority = (InterruptPriority)0,
				resetCooldownTimerOnUse = false,
				isCombatSkill = false,
				mustKeyPress = false,
				cancelSprintingOnActivation = false,
				rechargeStock = 1,
				requiredStock = 2,
				stockToConsume = 1
			});
			Skills.AddPassiveSkills(component.passiveSkillSlot.skillFamily, component.blinkPassive);
			component.impGauge = Skills.CreateSkillDef(new SkillDefInfo
			{
				skillName = "KENKO_SEAMSTRESS_NEEDLE_NAME",
				skillNameToken = "KENKO_SEAMSTRESS_NEEDLE_NAME",
				skillDescriptionToken = "KENKO_SEAMSTRESS_NEEDLE_DESCRIPTION",
				skillIcon = assetBundle.LoadAsset<Sprite>("texImpTouchedIcon"),
				keywordTokens = new string[1] { Tokens.needlesKeyword },
				activationState = new SerializableEntityStateType(typeof(Idle)),
				activationStateMachineName = "",
				baseMaxStock = 1,
				baseRechargeInterval = 0f,
				beginSkillCooldownOnSkillEnd = false,
				canceledFromSprinting = false,
				forceSprintDuringState = false,
				fullRestockOnAssign = true,
				interruptPriority = (InterruptPriority)0,
				resetCooldownTimerOnUse = false,
				isCombatSkill = false,
				mustKeyPress = false,
				cancelSprintingOnActivation = false,
				rechargeStock = 1,
				requiredStock = 2,
				stockToConsume = 1
			});
			Skills.AddPassiveSkills(component.impGaugeSkillSlot.skillFamily, component.impGauge);
		}

		private void AddPrimarySkills()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			SteppedSkillDef val = Skills.CreateSkillDef<SteppedSkillDef>(new SkillDefInfo("Trim", "KENKO_SEAMSTRESS_PRIMARY_TRIM_NAME", "KENKO_SEAMSTRESS_PRIMARY_TRIM_DESCRIPTION", assetBundle.LoadAsset<Sprite>("texFlurryIcon"), new SerializableEntityStateType(typeof(Trim))));
			val.stepCount = 3;
			val.stepGraceDuration = 0.5f;
			Skills.AddPrimarySkills(bodyPrefab, (SkillDef)val);
			SteppedSkillDef val2 = Skills.CreateSkillDef<SteppedSkillDef>(new SkillDefInfo("Flurry", "KENKO_SEAMSTRESS_PRIMARY_FLURRY_NAME", "KENKO_SEAMSTRESS_PRIMARY_FLURRY_DESCRIPTION", assetBundle.LoadAsset<Sprite>("texFlurryIcon"), new SerializableEntityStateType(typeof(Flurry))));
			val2.stepCount = 2;
			val2.stepGraceDuration = 0.5f;
			Skills.AddPrimarySkills(bodyPrefab, (SkillDef)val2);
		}

		private void AddSecondarySkills()
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			SkillDefInfo skillDefInfo = new SkillDefInfo();
			skillDefInfo.skillName = "Clip";
			skillDefInfo.skillNameToken = "KENKO_SEAMSTRESS_SECONDARY_CLIP_NAME";
			skillDefInfo.skillDescriptionToken = "KENKO_SEAMSTRESS_SECONDARY_CLIP_DESCRIPTION";
			skillDefInfo.keywordTokens = new string[0];
			skillDefInfo.skillIcon = assetBundle.LoadAsset<Sprite>("texClipIcon");
			skillDefInfo.activationState = new SerializableEntityStateType(typeof(Clip));
			skillDefInfo.activationStateMachineName = "Weapon";
			skillDefInfo.interruptPriority = (InterruptPriority)1;
			skillDefInfo.baseMaxStock = 1;
			skillDefInfo.baseRechargeInterval = 6f;
			skillDefInfo.rechargeStock = 1;
			skillDefInfo.requiredStock = 1;
			skillDefInfo.stockToConsume = 1;
			skillDefInfo.resetCooldownTimerOnUse = false;
			skillDefInfo.fullRestockOnAssign = false;
			skillDefInfo.dontAllowPastMaxStocks = false;
			skillDefInfo.beginSkillCooldownOnSkillEnd = false;
			skillDefInfo.mustKeyPress = true;
			skillDefInfo.isCombatSkill = true;
			skillDefInfo.canceledFromSprinting = false;
			skillDefInfo.cancelSprintingOnActivation = true;
			skillDefInfo.forceSprintDuringState = false;
			SkillDef val = Skills.CreateSkillDef(skillDefInfo);
			Skills.AddSecondarySkills(bodyPrefab, val);
			skillDefInfo = new SkillDefInfo();
			skillDefInfo.skillName = "PlanarManipulation";
			skillDefInfo.skillNameToken = "KENKO_SEAMSTRESS_SECONDARY_PLANMAN_NAME";
			skillDefInfo.skillDescriptionToken = "KENKO_SEAMSTRESS_SECONDARY_PLANMAN_DESCRIPTION";
			skillDefInfo.keywordTokens = new string[1] { Tokens.crushKeyword };
			skillDefInfo.skillIcon = assetBundle.LoadAsset<Sprite>("texPlanarManipulationIcon");
			skillDefInfo.activationState = new SerializableEntityStateType(typeof(PlanarManipulation));
			skillDefInfo.activationStateMachineName = "Weapon2";
			skillDefInfo.interruptPriority = (InterruptPriority)1;
			skillDefInfo.baseMaxStock = 1;
			skillDefInfo.baseRechargeInterval = 0.5f;
			skillDefInfo.rechargeStock = 1;
			skillDefInfo.requiredStock = 0;
			skillDefInfo.stockToConsume = 0;
			skillDefInfo.resetCooldownTimerOnUse = false;
			skillDefInfo.fullRestockOnAssign = false;
			skillDefInfo.dontAllowPastMaxStocks = false;
			skillDefInfo.beginSkillCooldownOnSkillEnd = false;
			skillDefInfo.mustKeyPress = true;
			skillDefInfo.isCombatSkill = true;
			skillDefInfo.canceledFromSprinting = false;
			skillDefInfo.cancelSprintingOnActivation = false;
			skillDefInfo.forceSprintDuringState = false;
			SeamstressTrackingSkillDef seamstressTrackingSkillDef = Skills.CreateSkillDef<SeamstressTrackingSkillDef>(skillDefInfo);
			Skills.AddSecondarySkills(bodyPrefab, seamstressTrackingSkillDef);
		}

		private void AddUtilitySkills()
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			SkillDefInfo skillDefInfo = new SkillDefInfo();
			skillDefInfo.skillName = "HeartDashSeamstress";
			skillDefInfo.skillNameToken = "KENKO_SEAMSTRESS_UTILITY_HEARTDASH_NAME";
			skillDefInfo.skillDescriptionToken = "KENKO_SEAMSTRESS_UTILITY_HEARTDASH_DESCRIPTION";
			skillDefInfo.keywordTokens = new string[1] { Tokens.insatiableKeyword };
			skillDefInfo.skillIcon = assetBundle.LoadAsset<Sprite>("texGlimpseOfCorruptionIcon");
			skillDefInfo.activationState = new SerializableEntityStateType(typeof(HealthCostDash));
			skillDefInfo.activationStateMachineName = "Weapon";
			skillDefInfo.interruptPriority = (InterruptPriority)1;
			skillDefInfo.baseRechargeInterval = 8f;
			skillDefInfo.baseMaxStock = 1;
			skillDefInfo.rechargeStock = 1;
			skillDefInfo.requiredStock = 1;
			skillDefInfo.stockToConsume = 1;
			skillDefInfo.resetCooldownTimerOnUse = false;
			skillDefInfo.fullRestockOnAssign = false;
			skillDefInfo.dontAllowPastMaxStocks = false;
			skillDefInfo.mustKeyPress = true;
			skillDefInfo.beginSkillCooldownOnSkillEnd = false;
			skillDefInfo.isCombatSkill = true;
			skillDefInfo.canceledFromSprinting = false;
			skillDefInfo.cancelSprintingOnActivation = false;
			skillDefInfo.forceSprintDuringState = false;
			SkillDef val = Skills.CreateSkillDef(skillDefInfo);
			Skills.AddUtilitySkills(bodyPrefab, val);
			skillDefInfo = new SkillDefInfo();
			skillDefInfo.skillName = "ParrySeamstress";
			skillDefInfo.skillNameToken = "KENKO_SEAMSTRESS_UTILITY_PARRY_NAME";
			skillDefInfo.skillDescriptionToken = "KENKO_SEAMSTRESS_UTILITY_PARRY_DESCRIPTION";
			skillDefInfo.keywordTokens = new string[1] { Tokens.insatiableKeyword };
			skillDefInfo.skillIcon = assetBundle.LoadAsset<Sprite>("texGlimpseOfPurityIcon");
			skillDefInfo.activationState = new SerializableEntityStateType(typeof(Parry));
			skillDefInfo.activationStateMachineName = "Weapon";
			skillDefInfo.interruptPriority = (InterruptPriority)2;
			skillDefInfo.baseRechargeInterval = 8f;
			skillDefInfo.baseMaxStock = 1;
			skillDefInfo.rechargeStock = 1;
			skillDefInfo.requiredStock = 1;
			skillDefInfo.stockToConsume = 1;
			skillDefInfo.resetCooldownTimerOnUse = false;
			skillDefInfo.fullRestockOnAssign = true;
			skillDefInfo.dontAllowPastMaxStocks = false;
			skillDefInfo.mustKeyPress = true;
			skillDefInfo.beginSkillCooldownOnSkillEnd = false;
			skillDefInfo.isCombatSkill = true;
			skillDefInfo.canceledFromSprinting = false;
			skillDefInfo.cancelSprintingOnActivation = true;
			skillDefInfo.forceSprintDuringState = false;
			parrySkillDef = Skills.CreateSkillDef(skillDefInfo);
			Skills.AddUtilitySkills(bodyPrefab, parrySkillDef);
			skillDefInfo = new SkillDefInfo();
			skillDefInfo.skillName = "Expunge";
			skillDefInfo.skillNameToken = "Expunge";
			skillDefInfo.skillDescriptionToken = "Expunge your core.";
			skillDefInfo.keywordTokens = new string[0];
			skillDefInfo.skillIcon = assetBundle.LoadAsset<Sprite>("texImpTouchedIcon");
			skillDefInfo.activationState = new SerializableEntityStateType(typeof(Explode));
			skillDefInfo.activationStateMachineName = "Weapon2";
			skillDefInfo.interruptPriority = (InterruptPriority)3;
			skillDefInfo.baseRechargeInterval = 0f;
			skillDefInfo.baseMaxStock = 1;
			skillDefInfo.rechargeStock = 0;
			skillDefInfo.requiredStock = 0;
			skillDefInfo.stockToConsume = 0;
			skillDefInfo.resetCooldownTimerOnUse = false;
			skillDefInfo.fullRestockOnAssign = true;
			skillDefInfo.dontAllowPastMaxStocks = true;
			skillDefInfo.beginSkillCooldownOnSkillEnd = false;
			skillDefInfo.mustKeyPress = true;
			skillDefInfo.isCombatSkill = false;
			skillDefInfo.canceledFromSprinting = false;
			skillDefInfo.cancelSprintingOnActivation = false;
			skillDefInfo.forceSprintDuringState = false;
			explodeSkillDef = Skills.CreateSkillDef(skillDefInfo);
		}

		private void AddSpecialSkills()
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			SkillDefInfo skillDefInfo = new SkillDefInfo();
			skillDefInfo.skillName = "FireSeamstress";
			skillDefInfo.skillNameToken = "KENKO_SEAMSTRESS_SPECIAL_FIRE_NAME";
			skillDefInfo.skillDescriptionToken = "KENKO_SEAMSTRESS_SPECIAL_FIRE_DESCRIPTION";
			skillDefInfo.keywordTokens = new string[2]
			{
				Tokens.symbioticKeyword,
				Tokens.details2Keyword
			};
			skillDefInfo.skillIcon = assetBundle.LoadAsset<Sprite>("texSkewerIcon");
			skillDefInfo.activationState = new SerializableEntityStateType(typeof(FireScissors));
			skillDefInfo.activationStateMachineName = "Weapon";
			skillDefInfo.interruptPriority = (InterruptPriority)1;
			skillDefInfo.baseRechargeInterval = 14f;
			skillDefInfo.baseMaxStock = 2;
			skillDefInfo.rechargeStock = 2;
			skillDefInfo.requiredStock = 1;
			skillDefInfo.stockToConsume = 1;
			skillDefInfo.resetCooldownTimerOnUse = false;
			skillDefInfo.fullRestockOnAssign = true;
			skillDefInfo.dontAllowPastMaxStocks = true;
			skillDefInfo.mustKeyPress = true;
			skillDefInfo.beginSkillCooldownOnSkillEnd = false;
			skillDefInfo.isCombatSkill = true;
			skillDefInfo.canceledFromSprinting = false;
			skillDefInfo.cancelSprintingOnActivation = true;
			skillDefInfo.forceSprintDuringState = false;
			SkillDef val = Skills.CreateSkillDef(skillDefInfo);
			Skills.AddSpecialSkills(bodyPrefab, val);
		}

		public static Material CreateMaterial(AssetBundle assetBundle, string materialName, float emission, Color emissionColor, float normalStrength)
		{
			//IL_0074: 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)
			if (!Object.op_Implicit((Object)(object)SeamstressAssets.commandoMat))
			{
				SeamstressAssets.commandoMat = Resources.Load<GameObject>("Prefabs/CharacterBodies/CommandoBody").GetComponentInChildren<CharacterModel>().baseRendererInfos[0].defaultMaterial;
			}
			Material val = Object.Instantiate<Material>(SeamstressAssets.commandoMat);
			Material val2 = assetBundle.LoadAsset<Material>(materialName);
			if (!Object.op_Implicit((Object)(object)val2))
			{
				return SeamstressAssets.commandoMat;
			}
			((Object)val).name = materialName;
			val.SetColor("_Color", val2.GetColor("_Color"));
			val.SetTexture("_MainTex", val2.GetTexture("_MainTex"));
			val.SetColor("_EmColor", emissionColor);
			val.SetFloat("_EmPower", emission);
			val.SetTexture("_EmTex", val2.GetTexture("_EmissionMap"));
			val.SetFloat("_NormalStrength", normalStrength);
			return val;
		}

		public static Material CreateMaterial(AssetBundle assetBundle, string materialName)
		{
			return CreateMaterial(assetBundle, materialName, 0f);
		}

		public static Material CreateMaterial(AssetBundle assetBundle, string materialName, float emission)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			return CreateMaterial(assetBundle, materialName, emission, Color.black);
		}

		public static Material CreateMaterial(AssetBundle assetBundle, string materialName, float emission, Color emissionColor)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			return CreateMaterial(assetBundle, materialName, emission, emissionColor, 0f);
		}

		public override void InitializeSkins()
		{
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Unknown result type (might be due to invalid IL or missing references)
			//IL_036d: Unknown result type (might be due to invalid IL or missing references)
			//IL_038d: Unknown result type (might be due to invalid IL or missing references)
			//IL_038f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0493: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_05db: Unknown result type (might be due to invalid IL or missing references)
			ModelSkinController val = ((Component)prefabCharacterModel).gameObject.AddComponent<ModelSkinController>();
			ChildLocator component = ((Component)prefabCharacterModel).GetComponent<ChildLocator>();
			RendererInfo[] baseRendererInfos = prefabCharacterModel.baseRendererInfos;
			List<SkinDef> list = new List<SkinDef>();
			SkinDef val2 = SeamstressSkins.CreateSkinDef("DEFAULT_SKIN", assetBundle.LoadAsset<Sprite>("texMainSkin"), baseRendererInfos, ((Component)prefabCharacterModel).gameObject);
			val2.meshReplacements = SeamstressSkins.getMeshReplacements(assetBundle, baseRendererInfos, "meshSeamstress", "meshScissorL", "meshScissorR", "meshSeamstressCrown", "meshHeart");
			val2.rendererInfos[0].defaultMaterial = assetBundle.LoadAsset<Material>("matSeamstress");
			val2.rendererInfos[1].defaultMaterial = assetBundle.LoadAsset<Material>("matScissors");
			val2.rendererInfos[2].defaultMaterial = assetBundle.LoadAsset<Material>("matScissors");
			val2.rendererInfos[3].defaultMaterial = assetBundle.LoadAsset<Material>("matSeamstress");
			val2.rendererInfos[4].defaultMaterial = assetBundle.LoadAsset<Material>("matSeamstress");
			list.Add(val2);
			SkinDef val3 = SeamstressSkins.CreateSkinDef("KENKO_SEAMSTRESS_MASTERY_SKIN_NAME", assetBundle.LoadAsset<Sprite>("texMonsoonBlue"), baseRendererInfos, ((Component)prefabCharacterModel).gameObject, SeamstressUnlockables.masterySkinUnlockableDef);
			val3.meshReplacements = SeamstressSkins.getMeshReplacements(assetBundle, baseRendererInfos, "meshPrincess", "meshPrincessSwordL", "meshPrincessSwordR", "meshPrincessCrown", null);
			val3.rendererInfos[0].defaultMaterial = assetBundle.LoadAsset<Material>("matPrincessBlue");
			val3.rendererInfos[1].defaultMaterial = assetBundle.LoadAsset<Material>("matPrincessSword");
			val3.rendererInfos[2].defaultMaterial = assetBundle.LoadAsset<Material>("matPrincessSword");
			val3.rendererInfos[3].defaultMaterial = assetBundle.LoadAsset<Material>("matPrincessBlueEmissions");
			val3.gameObjectActivations = (GameObjectActivation[])(object)new GameObjectActivation[1]
			{
				new GameObjectActivation
				{
					gameObject = component.FindChildGameObject("HeartModel"),
					shouldActivate = false
				}
			};
			SkinDef val4 = SeamstressSkins.CreateSkinDef("KENKO_SEAMSTRESS_MASTERY_SKIN_NAME2", assetBundle.LoadAsset<Sprite>("texMonsoonRed"), baseRendererInfos, ((Component)prefabCharacterModel).gameObject, SeamstressUnlockables.masterySkinUnlockableDef);
			val4.meshReplacements = SeamstressSkins.getMeshReplacements(assetBundle, baseRendererInfos, "meshPrincess", "meshPrincessSwordL", "meshPrincessSwordR", "meshPrincessCrown", null);
			val4.rendererInfos[0].defaultMaterial = assetBundle.LoadAsset<Material>("matPrincessRed");
			val4.rendererInfos[1].defaultMaterial = assetBundle.LoadAsset<Material>("matPrincessSwordAlt");
			val4.rendererInfos[2].defaultMaterial = assetBundle.LoadAsset<Material>("matPrincessSwordAlt");
			val4.rendererInfos[3].defaultMaterial = assetBundle.LoadAsset<Material>("matPrincessRedEmissions");
			val4.gameObjectActivations = (GameObjectActivation[])(object)new GameObjectActivation[1]
			{
				new GameObjectActivation
				{
					gameObject = component.FindChildGameObject("HeartModel"),
					shouldActivate = false
				}
			};
			SkinDef val5 = SeamstressSkins.CreateSkinDef("KENKO_SEAMSTRESS_MASTERY_SKIN_NAME3", assetBundle.LoadAsset<Sprite>("ravenIcon"), baseRendererInfos, ((Component)prefabCharacterModel).gameObject, SeamstressUnlockables.masteryTyphoonSkinUnlockableDef);
			val5.meshReplacements = SeamstressSkins.getMeshReplacements(assetBundle, baseRendererInfos, "meshRaven", "meshShadowClawsL", "meshShadowClawsR", "meshRavenCrown", null);
			val5.rendererInfos[0].defaultMaterial = assetBundle.LoadAsset<Material>("matRaven");
			val5.rendererInfos[1].defaultMaterial = assetBundle.LoadAsset<Material>("matRavenShadowClaws");
			val5.rendererInfos[2].defaultMaterial = assetBundle.LoadAsset<Material>("matRavenShadowClaws");
			val5.rendererInfos[3].defaultMaterial = assetBundle.LoadAsset<Material>("matRaven");
			val5.gameObjectActivations = (GameObjectActivation[])(object)new GameObjectActivation[1]
			{
				new GameObjectActivation
				{
					gameObject = component.FindChildGameObject("HeartModel"),
					shouldActivate = false
				}
			};
			SkinDef val6 = SeamstressSkins.CreateSkinDef("KENKO_SEAMSTRESS_MASTERY_SKIN_NAME4", assetBundle.LoadAsset<Sprite>("ravenIcon"), baseRendererInfos, ((Component)prefabCharacterModel).gameObject, SeamstressUnlockables.masteryTyphoonSkinUnlockableDef);
			val6.meshReplacements = SeamstressSkins.getMeshReplacements(assetBundle, baseRendererInfos, "meshRavenAlt", "meshShadowClawsL", "meshShadowClawsR", "meshRavenCrownAlt", null);
			val6.rendererInfos[0].defaultMaterial = assetBundle.LoadAsset<Material>("matRavenAlt");
			val6.rendererInfos[1].defaultMaterial = assetBundle.LoadAsset<Material>("matRavenShadowClaws");
			val6.rendererInfos[2].defaultMaterial = assetBundle.LoadAsset<Material>("matRavenShadowClaws");
			val6.rendererInfos[3].defaultMaterial = assetBundle.LoadAsset<Material>("matRavenAltEmission");
			val6.gameObjectActivations = (GameObjectActivation[])(object)new GameObjectActivation[1]
			{
				new GameObjectActivation
				{
					gameObject = component.FindChildGameObject("HeartModel"),
					shouldActivate = false
				}
			};
			list.Add(val3);
			list.Add(val4);
			list.Add(val5);
			list.Add(val6);
			val.skins = list.ToArray();
		}

		public override void InitializeCharacterMaster()
		{
			SeamstressAI.Init(bodyPrefab, masterName);
		}

		private void AddHooks()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Expected O, but got Unknown
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Expected O, but got Unknown
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Expected O, but got Unknown
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Expected O, but got Unknown
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: 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
			((ResourceAvailability)(ref BodyCatalog.availability)).CallWhenAvailable((Action)CacheBodyIndex);
			HUD.onHudTargetChangedGlobal += HUDSetup;
			HealthComponent.Heal += new hook_Heal(HealthComponent_Heal);
			CharacterModel.UpdateOverlays += new hook_UpdateOverlays(CharacterModel_UpdateOverlays);
			CharacterModel.UpdateOverlayStates += new hook_UpdateOverlayStates(CharacterModel_UpdateOverlayStates);
			HealthComponent.TakeDamageProcess += new hook_TakeDamageProcess(HealthComponent_TakeDamageProcess);
			GenericSkill.SetBonusStockFromBody += new hook_SetBonusStockFromBody(GenericSkill_SetBonusStockFromBody);
			ImmuneToDebuffBehavior.OverrideDot += new hook_OverrideDot(ImmuneToDebuffBehavior_OverrideDot);
			DotController.AddDot_GameObject_float_HurtBox_DotIndex_float_Nullable1_Nullable1_Nullable1 += new hook_AddDot_GameObject_float_HurtBox_DotIndex_float_Nullable1_Nullable1_Nullable1(DotController_AddDot);
			DotController.EvaluateDotStacksForType += new hook_EvaluateDotStacksForType(DotController_EvaluateDotStacksForType);
			ImportanceCompat.Importance();
			RecalculateStatsAPI.GetStatCoefficients += new StatHookEventHandler(RecalculateStatsAPI_GetStatCoefficients);
			SurvivorCatalog.Init += new hook_Init(SurvivorCatalog_Init);
		}

		private void CacheBodyIndex()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Invalid comparison between Unknown and I4
			seamstressBodyIndex = BodyCatalog.FindBodyIndex(bodyName);
			if ((int)seamstressBodyIndex == -1)
			{
				Log.Error("Could not find SeamstressBody in the body catalog.");
			}
		}

		private void DotController_AddDot(orig_AddDot_GameObject_float_HurtBox_DotIndex_float_Nullable1_Nullable1_Nullable1 orig, DotController self, GameObject attackerObject, float duration, HurtBox hitHurtBox, DotIndex dotIndex, float damageMultiplier, uint? maxStacksFromAttacker, float? totalDamage, DotIndex? preUpgradeDotIndex)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0339: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_030c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
			if (!NetworkServer.active)
			{
				Debug.LogWarning((object)"[Server] function 'System.Void RoR2.DotController::AddDot(UnityEngine.GameObject,System.Single,RoR2.HurtBox,RoR2.DotController/DotIndex,System.Single,System.Nullable`1<System.UInt32>,System.Nullable`1<System.Single>,System.Nullable`1<RoR2.DotController/DotIndex>)' called on client");
				return;
			}
			if (dotIndex != SeamstressDots.SeamstressSelfBleed || !Object.op_Implicit((Object)(object)attackerObject))
			{
				orig.Invoke(self, attackerObject, duration, hitHurtBox, dotIndex, damageMultiplier, maxStacksFromAttacker, totalDamage, preUpgradeDotIndex);
				return;
			}
			CharacterBody component = attackerObject.GetComponent<CharacterBody>();
			TeamComponent component2 = attackerObject.GetComponent<TeamComponent>();
			if (Object.op_Implicit((Object)(object)component) && Object.op_Implicit((Object)(object)component2) && component.bodyIndex == seamstressBodyIndex)
			{
				DotDef val = DotController.dotDefs[dotIndex];
				DotStack val2 = ((BasePool<DotStack>)(object)DotController.dotStackPool).Request();
				val2.dotIndex = dotIndex;
				val2.dotDef = val;
				val2.attackerObject = attackerObject;
				val2.attackerTeam = (TeamIndex)0;
				val2.timer = duration;
				val2.totalDuration = duration;
				val2.damage = GetSelfBleedDamage(self.victimBody.healthComponent);
				val2.damageType = DamageTypeCombo.op_Implicit((DamageType)67108931);
				val2.hitHurtBox = hitHurtBox;
				int num = 0;
				int i = 0;
				for (int count = self.dotStackList.Count; i < count; i++)
				{
					if (self.dotStackList[i].dotIndex == dotIndex)
					{
						num++;
					}
				}
				if (val2.damage > 0f && !Mathf.Approximately(damageMultiplier, 0f))
				{
					val2.damage = Mathf.Max(1f, val2.damage);
				}
				if (totalDamage.HasValue && val2.damage != 0f)
				{
					duration = totalDamage.Value * val.interval / val2.damage;
					val2.timer = duration;
					val2.totalDuration = duration;
				}
				if (maxStacksFromAttacker.HasValue)
				{
					DotStack val3 = null;
					int num2 = 0;
					int j = 0;
					for (int count2 = self.dotStackList.Count; j < count2; j++)
					{
						DotStack val4 = self.dotStackList[j];
						if (val4.dotIndex == dotIndex && (Object)(object)val4.attackerObject == (Object)(object)attackerObject)
						{
							num2++;
							if (val3 == null || val4.timer < val3.timer)
							{
								val3 = val4;
							}
						}
					}
					if (num2 >= maxStacksFromAttacker.Value && val3 != null)
					{
						if (val3.timer < duration)
						{
							val3.timer = duration;
							val3.totalDuration = duration;
							val3.damage = val2.damage;
							val3.damageType = val2.damageType;
						}
						return;
					}
				}
				if (num == 0 || val.resetTimerOnAdd)
				{
					self.NetworkactiveDotFlags = self.activeDotFlags | (uint)(1 << (int)dotIndex);
					self.dotTimers[dotIndex] = val.interval;
				}
				self.dotStackList.Add(val2);
				self.OnDotStackAddedServer(val2);
			}
			else
			{
				orig.Invoke(self, attackerObject, duration, hitHurtBox, dotIndex, damageMultiplier, maxStacksFromAttacker, totalDamage, preUpgradeDotIndex);
			}
		}

		private static float GetSelfBleedDamage(HealthComponent healthComponent)
		{
			return (healthComponent.health + healthComponent.shield) * SeamstressConfig.selfBleedHealthCoefficient.Value;
		}

		private void DotController_EvaluateDotStacksForType(orig_EvaluateDotStacksForType orig, DotController self, DotIndex dotIndex, float dt, out int remainingActive)
		{
			//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_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			if (NetworkServer.active && dotIndex == SeamstressDots.SeamstressSelfBleed && Object.op_Implicit((Object)(object)self.victimHealthComponent))
			{
				float num = GetSelfBleedDamage(self.victimHealthComponent);
				if (num > 0f)
				{
					num = Mathf.Max(1f, num);
				}
				foreach (DotStack dotStack in self.dotStackList)
				{
					if (dotStack.dotIndex == dotIndex)
					{
						dotStack.damage = num;
					}
				}
			}
			orig.Invoke(self, dotIndex, dt, ref remainingActive);
		}

		private void SurvivorCatalog_Init(orig_Init orig)
		{
			orig.Invoke();
			if (SeamstressPlugin.emotesInstalled)
			{
				EmotesAPICompat.Emotes();
			}
		}

		private void CharacterModel_UpdateOverlays(orig_UpdateOverlays orig, CharacterModel self)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(self);
			if (Object.op_Implicit((Object)(object)self) && Object.op_Implicit((Object)(object)self.body) && self.body.bodyIndex == seamstressBodyIndex)
			{
				SeamstressController component = ((Component)self.body).GetComponent<SeamstressController>();
				InsatiableController component2 = ((Component)self.body).GetComponent<InsatiableController>();
				bool flag = self.body.HasBuff(SeamstressBuffs.SeamstressInsatiableBuff) && Object.op_Implicit((Object)(object)component2) && !component2.hasStartedInsatiable;
				AddOverlay(component.blue ? SeamstressAssets.insatiableOverlayMat2 : SeamstressAssets.insatiableOverlayMat, flag);
				if (flag)
				{
					TemporaryOverlayInstance val = TemporaryOverlayManager.AddOverlay(((Component)self).gameObject);
					val.duration = 0.6f;
					val.alphaCurve = AnimationCurve.EaseInOut(0f, 1f, 1f, 0.4f);
					val.animateShaderAlpha = true;
					val.destroyComponentOnEnd = true;
					val.originalMaterial = (component.blue ? SeamstressAssets.insatiableOverlayMat2 : SeamstressAssets.insatiableOverlayMat);
				}
			}
			void AddOverlay(Material overlayMaterial, bool condition)
			{
				if (self.activeOverlayCount < CharacterModel.maxOverlays && condition)
				{
					Material[] currentOverlays = self.currentOverlays;
					CharacterModel obj = self;
					int activeOverlayCount = obj.activeOverlayCount;
					obj.activeOverlayCount = activeOverlayCount + 1;
					currentOverlays[activeOverlayCount] = overlayMaterial;
				}
			}
		}

		private bool CharacterModel_UpdateOverlayStates(orig_UpdateOverlayStates orig, CharacterModel self)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			bool flag = orig.Invoke(self);
			if (!Object.op_Implicit((Object)(object)self) || !Object.op_Implicit((Object)(object)self.body) || self.body.bodyIndex != seamstressBodyIndex)
			{
				return flag;
			}
			InsatiableController component = ((Component)self.body).GetComponent<InsatiableController>();
			SetOverlayFlag(self.baseRendererInfos.Length, self.body.HasBuff(SeamstressBuffs.SeamstressInsatiableBuff) && Object.op_Implicit((Object)(object)component) && !component.hasStartedInsatiable);
			return self.oldOverlays != self.activeOverlays || flag;
			void SetOverlayFlag(int index, bool condition)
			{
				if (condition)
				{
					CharacterModel obj = self;
					obj.activeOverlays |= 1 << index;
				}
			}
		}

		private bool ImmuneToDebuffBehavior_OverrideDot(orig_OverrideDot orig, InflictDotInfo inflictDotInfo)
		{
			//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_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: 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)
			if (inflictDotInfo.dotIndex != SeamstressDots.SeamstressSelfBleed)
			{
				return orig.Invoke(inflictDotInfo);
			}
			GameObject victimObject = inflictDotInfo.victimObject;
			CharacterBody val = ((victimObject != null) ? victimObject.GetComponent<CharacterBody>() : null);
			if (Object.op_Implicit((Object)(object)val) && val.bodyIndex != seamstressBodyIndex)
			{
				return false;
			}
			return orig.Invoke(inflictDotInfo);
		}

		private void HealthComponent_TakeDamageProcess(orig_TakeDamageProcess orig, HealthComponent self, DamageInfo damageInfo)
		{
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			float num = 0f;
			if (NetworkServer.active && self.alive && Object.op_Implicit((Object)(object)self.body))
			{
				if ((self.body.HasBuff(SeamstressBuffs.ParryStart) || self.body.HasBuff(SeamstressBuffs.ParrySuccess)) && damageInfo.damage > 0f)
				{
					if (self.body.HasBuff(SeamstressBuffs.ParryStart))
					{
						self.body.RemoveBuff(SeamstressBuffs.ParryStart);
					}
					if (!self.body.HasBuff(SeamstressBuffs.ParrySuccess))
					{
						self.body.AddBuff(SeamstressBuffs.ParrySuccess);
					}
					damageInfo.rejected = true;
				}
				else if (self.body.HasBuff(SeamstressBuffs.SeamstressInsatiableBuff) && damageInfo.dotIndex != SeamstressDots.SeamstressSelfBleed)
				{
					SeamstressController component = ((Component)self.body).gameObject.GetComponent<SeamstressController>();
					DotController val = DotController.FindDotController(((Component)self).gameObject);
					if (Object.op_Implicit((Object)(object)component) && Object.op_Implicit((Object)(object)val) && val.HasDotActive(SeamstressDots.SeamstressSelfBleed) && !self.body.HasBuff(Buffs.HiddenInvincibility))
					{
						if (damageInfo.damage >= self.combinedHealth && self.body.skillLocator.utility.skillDef.skillIndex == explodeSkillDef.skillIndex)
						{
							self.body.skillLocator.utility.ExecuteIfReady();
						}
						damageInfo.rejected = true;
					}
				}
				else if (self.body.HasBuff(SeamstressBuffs.SeamstressInsatiableBuff) && damageInfo.dotIndex == SeamstressDots.SeamstressSelfBleed)
				{
					num = self.barrier;
					if (num > 0f)
					{
						self.AddBarrier(0f - num);
					}
				}
			}
			orig.Invoke(self, damageInfo);
			if (NetworkServer.active && Object.op_Implicit((Object)(object)self.body) && self.body.HasBuff(SeamstressBuffs.SeamstressInsatiableBuff))
			{
				if (num > 0f)
				{
					self.body.healthComponent.AddBarrier(num);
				}
				SeamstressDamageScalingController component2 = ((Component)self.body).GetComponent<SeamstressDamageScalingController>();
				if (Object.op_Implicit((Object)(object)component2))
				{
					component2.RecalculateStatsIfNeeded();
				}
			}
		}

		private float HealthComponent_Heal(orig_Heal orig, HealthComponent self, float amount, ProcChainMask procChainMask, bool nonRegen = true)
		{
			//IL_0087: 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)
			if (Object.op_Implicit((Object)(object)self.body))
			{
				bool flag = false;
				if (Object.op_Implicit((Object)(object)self) && self.body.HasBuff(SeamstressBuffs.SeamstressInsatiableBuff))
				{
					flag = true;
					amount *= SeamstressConfig.healConversion.Value;
				}
				float num = orig.Invoke(self, amount, procChainMask, nonRegen);
				if (flag)
				{
					self.AddBarrier(num / SeamstressConfig.healConversion.Value * (1f - SeamstressConfig.healConversion.Value));
				}
				return num;
			}
			return orig.Invoke(self, amount, procChainMask, nonRegen);
		}

		public void GenericSkill_SetBonusStockFromBody(orig_SetBonusStockFromBody orig, GenericSkill self, int newBonusStockFromBody)
		{
			if (!Object.op_Implicit((Object)(object)self) || ((!self.skillDef.dontAllowPastMaxStocks || self.skillDef.skillIndex != SkillCatalog.FindSkillIndexByName("FireScepterSeamstress")) && self.skillDef.skillIndex != SkillCatalog.FindSkillIndexByName("FireSeamstress")))
			{
				orig.Invoke(self, newBonusStockFromBody);
			}
		}

		private void RecalculateStatsAPI_GetStatCoefficients(CharacterBody sender, StatHookEventArgs args)
		{
			SeamstressController component = ((Component)sender).GetComponent<SeamstressController>();
			if (Object.op_Implicit((Object)(object)component))
			{
				if (sender.HasBuff(SeamstressBuffs.SeamstressInsatiableBuff))
				{
					args.attackSpeedMultAdd += 0.2f;
					args.baseMoveSpeedAdd += 2f;
				}
				if (!sender.HasBuff(SeamstressBuffs.ScissorLeftBuff))
				{
					args.attackSpeedMultAdd += 0.1f;
				}
				if (!sender.HasBuff(SeamstressBuffs.ScissorRightBuff))
				{
					args.attackSpeedMultAdd += 0.1f;
				}
				if (Object.op_Implicit((Object)(object)sender.inventory) && sender.inventory.GetItemCountEffective(Items.EquipmentMagazineVoid) != 0)
				{
					args.attackSpeedMultAdd += 0.1f * (float)sender.inventory.GetItemCountEffective(Items.EquipmentMagazineVoid);
				}
			}
		}

		internal static void HUDSetup(HUD hud)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Invalid comparison between Unknown and I4
			//IL_0046: 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)
			if (!Object.op_Implicit((Object)(object)hud))
			{
				return;
			}
			NeedleHudController needleHudController = ((Component)hud).GetComponent<NeedleHudController>();
			CharacterMaster targetMaster = hud.targetMaster;
			CharacterBody val = (Object.op_Implicit((Object)(object)targetMaster) ? targetMaster.GetBody() : null);
			if (!Object.op_Implicit((Object)(object)val) || (int)seamstressBodyIndex == -1 || val.bodyIndex != seamstressBodyIndex || !((NetworkBehaviour)targetMaster).hasAuthority)
			{
				if (Object.op_Implicit((Object)(object)needleHudController))
				{
					needleHudController.SetTarget(null);
				}
				return;
			}
			if (!Object.op_Implicit((Object)(object)needleHudController))
			{
				needleHudController = ((Component)hud).gameObject.AddComponent<NeedleHudController>();
			}
			needleHudController.SetTarget(val);
		}
	}
}
namespace SeamstressMod.Seamstress.SkillStates
{
	public class Clip : BaseSeamstressSkillState
	{
		public GameObject clawSlash = SeamstressAssets.clawSlashEffect;

		public GameObject hitEffectPrefab = SeamstressAssets.scissorsHitImpactEffect;

		public GameObject swingEffectPrefab = SeamstressAssets.scissorsSlashComboEffect;

		public GameObject wideEffectPrefab = SeamstressAssets.wideSlashEffect;

		private GameObject swingEffectInstance;

		protected EffectManagerHelper _emh_swingEffectInstance;

		private GameObject swingEffectInstance2;

		protected EffectManagerHelper _emh_swingEffectInstance2;

		protected Animator animator;

		private OverlapAttack overlapAttack;

		private DamageType damageType = (DamageType)0;

		private ModdedDamageType moddedDamageType = DamageTypes.CutDamage;

		private ModdedDamageType moddedDamageType2 = DamageTypes.SeamstressLifesteal;

		private float damageCoefficient;

		private float procCoefficient;

		private float pushForce = 0f;

		private Vector3 bonusForce = Vector3.zero;

		protected float stopwatch;

		private HitStopCachedState hitStopCachedState;

		private float hitPauseTimer;

		protected float hitStopDuration = 0.01f;

		protected bool inHitPause;

		protected string playbackRateParam = "Slash.playbackRate";

		protected string hitBoxString = "SwordBig";

		private int snips;

		private int alternateSwings = 0;

		private float baseDuration = 0.75f;

		private float duration;

		private float firstSnip;

		private float secondSnip;

		private float snipInterval;

		private float lastSnip;

		private bool hasFired;

		private bool hasFired2;

		private bool noScissors;

		private bool inAir;

		private Vector3 storedVelocity;

		public override void OnEnter()
		{
			RefreshState();
			damageCoefficient = SeamstressConfig.clipDamageCoefficient.Value;
			procCoefficient = SeamstressConfig.clipProcCoefficient.Value;
			if (seamstressController.blue)
			{
				clawSlash = SeamstressAssets.clawSlashEffect2;
				hitEffectPrefab = SeamstressAssets.scissorsHitImpactEffect2;
				swingEffectPrefab = SeamstressAssets.scissorsSlashComboEffect2;
				wideEffectPrefab = SeamstressAssets.wideSlashEffect2;
			}
			base.OnEnter();
			baseDuration = 0.75f;
			snips = needleCount;
			if (!scissorRight || !scissorLeft)
			{
				noScissors = true;
			}
			if (noScissors)
			{
				hitBoxString = "Sword";
			}
			animator = ((EntityState)this).GetModelAnimator();
			duration = baseDuration / ((BaseState)this).attackSpeedStat;
			firstSnip = duration * 0.2f;
			secondSnip = duration * 0.4f;
			snipInterval = 0f;
			lastSnip = duration - firstSnip;
			if (!((EntityState)this).characterMotor.isGrounded)
			{
				inAir = true;
			}
			((BaseState)this).StartAimMode(duration, false);
			PlayAttackAnimation();
			if (inAir)
			{
				((BaseState)this).SmallHop(((EntityState)this).characterMotor, 6f);
			}
		}

		public override void FixedUpdate()
		{
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: 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_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			base.FixedUpdate();
			hitPauseTimer -= Time.fixedDeltaTime;
			if (hitPauseTimer <= 0f && inHitPause)
			{
				RemoveHitstop();
			}
			if (!inHitPause)
			{
				stopwatch += Time.fixedDeltaTime;
				if (inAir && ((EntityState)this).isAuthority)
				{
					Vector3 velocity = ((EntityState)this).characterDirection.forward * ((BaseState)this).moveSpeedStat * Mathf.Lerp(3f, 1f, ((EntityState)this).age / duration);
					velocity.y = ((EntityState)this).characterMotor.velocity.y;
					((EntityState)this).characterMotor.velocity = velocity;
				}
			}
			else
			{
				if (Object.op_Implicit((Object)(object)((EntityState)this).characterMotor))
				{
					((EntityState)this).characterMotor.velocity = Vector3.zero;
				}
				if (Object.op_Implicit((Object)(object)animator))
				{
					animator.SetFloat(playbackRateParam, 0f);
				}
			}
			if (stopwatch >= firstSnip && !hasFired)
			{
				hasFired = true;
				EnterAttack();
				FireAttack();
			}
			if (stopwatch >= secondSnip + snipInterval && snipInterval <= secondSnip && snips > 0)
			{
				EnterAttack();
				FireAttack();
				snips--;
				snipInterval += secondSnip / 5f;
				Util.PlaySound("Play_bandit2_m2_alt_throw", ((EntityState)this).gameObject);
			}
			if (stopwatch >= lastSnip && !hasFired2)
			{
				hasFired2 = true;
				EnterAttack();
				FireAttack();
			}
			if (stopwatch >= duration && snips == 0 && ((EntityState)this).isAuthority)
			{
				((EntityState)this).outer.SetNextStateToMain();
			}
		}

		protected void ApplyHitstop()
		{
			//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_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			if (!inHitPause && hitStopDuration > 0f)
			{
				storedVelocity = ((EntityState)this).characterMotor.velocity;
				hitStopCachedState = ((BaseState)this).CreateHitStopCachedState(((EntityState)this).characterMotor, animator, playbackRateParam);
				hitPauseTimer = hitStopDuration / ((BaseState)this).attackSpeedStat;
				inHitPause = true;
			}
		}

		private void RemoveHitstop()
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			((BaseState)this).ConsumeHitStopCachedState(hitStopCachedState, ((EntityState)this).characterMotor, animator);
			inHitPause = false;
			((EntityState)this).characterMotor.velocity = storedVelocity;
		}

		protected virtual void OnHitEnemyAuthority()
		{
			ApplyHitstop();
		}

		private void EnterAttack()
		{
			if (noScissors)
			{
				Util.PlayAttackSpeedSound("Play_imp_attack", ((EntityState)this).gameObject, ((BaseState)this).attackSpeedStat);
			}
			else
			{
				Util.PlayAttackSpeedSound("Play_bandit2_m2_impact", ((EntityState)this).gameObject, ((BaseState)this).attackSpeedStat);
			}
		}

		protected virtual void DetermineSwing()
		{
			Transform attachedTransform = ((BaseState)this).FindModelChild("SwingCenter");
			GameObject effect = clawSlash;
			PlaySwingEffect(attachedTransform, effect);
			if (noScissors)
			{
				effect = clawSlash;
				if (hasFired && !hasFired2)
				{
					if (alternateSwings == 0)
					{
						attachedTransform = ((BaseState)this).FindModelChild("SwingLeftSmall");
						alternateSwings = 1;
					}
					else if (alternateSwings == 1)
					{
						attachedTransform = ((BaseState)this).FindModelChild("SwingRightSmall");
						alternateSwings = 0;
					}
				}
				else if (hasFired2)
				{
					attachedTransform = ((BaseState)this).FindModelChild("SwingRightSmall");
				}
			}
			else if (inAir)
			{
				effect = wideEffectPrefab;
				if (hasFired && !hasFired2)
				{
					if (alternateSwings == 0)
					{
						attachedTransform = ((BaseState)this).FindModelChild("SwingCharAirCenter2");
						alternateSwings = 1;
					}
					else if (alternateSwings == 1)
					{
						attachedTransform = ((BaseState)this).FindModelChild("SwingCharAirCenter");
						alternateSwings = 0;
					}
				}
				else if (hasFired2)
				{
					attachedTransform = ((BaseState)this).FindModelChild("SwingCharAirCenter");
				}
			}
			else
			{
				if (hasFired && !hasFired2)
				{
					if (alternateSwings == 0)
					{
						attachedTransform = ((BaseState)this).FindModelChild("SwingLeftSmall");
						alternateSwings = 1;
					}
					else if (alternateSwings == 1)
					{
						attachedTransform = ((BaseState)this).FindModelChild("SwingRightSmall");
						alternateSwings = 0;
					}
				}
				else if (hasFired2)
				{
					attachedTransform = ((BaseState)this).FindModelChild("SwingRightSmall");
				}
				PlaySwingEffect(((BaseState)this).FindModelChild("SwingCenter"), swingEffectPrefab);
			}
			PlaySwingEffect(attachedTransform, effect);
		}

		protected virtual void PlaySwingEffect(Transform attachedTransform, GameObject Effect)
		{
			if (!EffectManager.ShouldUsePooledEffect(Effect))
			{
				swingEffectInstance = Object.Instantiate<GameObject>(Effect, attachedTransform);
			}
			else
			{
				_emh_swingEffectInstance = EffectManager.GetAndActivatePooledEffect(Effect, attachedTransform, true);
				swingEffectInstance = ((Component)_emh_swingEffectInstance).gameObject;
			}
			ScaleParticleSystemDuration component = swingEffectInstance.GetComponent<ScaleParticleSystemDuration>();
			if (Object.op_Implicit((Object)(object)component))
			{
				component.newDuration = component.initialDuration;
			}
		}

		protected virtual void PlaySwingEffect2(Transform attachedTransform, GameObject Effect)
		{
			if (Object.op_Implicit((Object)(object)attachedTransform))
			{
				if (!EffectManager.ShouldUsePooledEffect(Effect))
				{
					swingEffectInstance2 = Object.Instantiate<GameObject>(Effect, attachedTransform);
				}
				else
				{
					_emh_swingEffectInstance2 = EffectManager.GetAndActivatePooledEffect(Effect, attachedTransform, true);
					swingEffectInstance2 = ((Component)_emh_swingEffectInstance2).gameObject;
				}
				ScaleParticleSystemDuration component = swingEffectInstance2.GetComponent<ScaleParticleSystemDuration>();
				if (Object.op_Implicit((Object)(object)component))
				{
					component.newDuration = component.initialDuration;
				}
			}
		}

		protected virtual void FireAttack()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			overlapAttack = new OverlapAttack();
			overlapAttack.damageType = DamageTypeCombo.op_Implicit(damageType);
			if (isInsatiable)
			{
				DamageAPI.AddModdedDamageType(ref overlapAttack.damageType, moddedDamageType);
			}
			DamageAPI.AddModdedDamageType(ref overlapAttack.damageType, moddedDamageType2);
			overlapAttack.attacker = ((EntityState)this).gameObject;
			overlapAttack.inflictor = ((EntityState)this).gameObject;
			overlapAttack.teamIndex = ((BaseState)this).GetTeam();
			overlapAttack.damage = damageCoefficient * ((BaseState)this).damageStat;
			overlapAttack.procCoefficient = procCoefficient;
			overlapAttack.hitEffectPrefab = hitEffectPrefab;
			overlapAttack.forceVector = bonusForce;
			overlapAttack.pushAwayForce = pushForce;
			overlapAttack.hitBoxGroup = ((BaseState)this).FindHitBoxGroup(hitBoxString);
			overlapAttack.isCrit = ((BaseState)this).RollCrit();
			overlapAttack.damageType.damageSource = (DamageSource)2;
			if (((EntityState)this).isAuthority)
			{
				Ray aimRay = ((BaseState)this).GetAimRay();
				Vector3 direction = ((Ray)(ref aimRay)).direction;
				((BaseState)this).FindModelChild("SwingPivot").rotation = Util.QuaternionSafeLookRotation(direction);
				if (overlapAttack.Fire((List<HurtBox>)null))
				{
					OnHitEnemyAuthority();
				}
			}
			DetermineSwing();
		}

		public override InterruptPriority GetMinimumInterruptPriority()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			if (stopwatch >= duration)
			{
				return (InterruptPriority)0;
			}
			return (InterruptPriority)2;
		}

		private void PlayAttackAnimation()
		{
			((EntityState)this).PlayCrossfade("Gesture, Override", "Clip", "Slash.playbackRate", duration * 1.7f, 0.1f * duration);
		}

		public override void OnExit()
		{
			if (((EntityState)this).isAuthority)
			{
				if ((Object)(object)_emh_swingEffectInstance != (Object)null && _emh_swingEffectInstance.OwningPool != null)
				{
					((GenericPool<EffectManagerHelper>)(object)_emh_swingEffectInstance.OwningPool).ReturnObject(_emh_swingEffectInstance);
				}
				else if (Object.op_Implicit((Object)(object)swingEffectInstance))
				{
					EntityState.Destroy((Object)(object)swingEffectInstance);
				}
				swingEffectInstance = null;
				_emh_swingEffectInstance = null;
				if ((Object)(object)_emh_swingEffectInstance2 != (Object)null && _emh_swingEffectInstance2.OwningPool != null)
				{
					((GenericPool<EffectManagerHelper>)(object)_emh_swingEffectInstance2.OwningPool).ReturnObject(_emh_swingEffectInstance2);
				}
				else if (Object.op_Implicit((Object)(object)swingEffectInstance2))
				{
					EntityState.Destroy((Object)(object)swingEffectInstance2);
				}
				swingEffectInstance2 = null;
				_emh_swingEffectInstance2 = null;
			}
			((EntityState)this).OnExit();
		}
	}
	public class Explode : BaseSeamstressSkillState
	{
		public float baseDuration = 0.5f;

		public BlastAttack BlastAttack;

		public override void OnEnter()
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			//IL_001f: 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_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			base.OnEnter();
			BlastAttack = new BlastAttack();
			BlastAttack.position = ((EntityState)this).transform.position;
			BlastAttack.baseDamage = ((BaseState)this).damageStat * Mathf.Lerp(SeamstressConfig.explodeMinDamageCoefficient.Value, SeamstressConfig.explodeMaxDamageCoefficient.Value, ((EntityState)this).healthComponent.barrier / ((EntityState)this).characterBody.maxBarrier);
			BlastAttack.baseForce = 800f;
			BlastAttack.bonusForce = Vector3.zero;
			BlastAttack.radius = Mathf.Lerp(10f, 30f, ((EntityState)this).healthComponent.barrier / ((EntityState)this).characterBody.maxBarrier);
			BlastAttack.attacker = ((EntityState)this).gameObject;
			BlastAttack.inflictor = ((EntityState)this).gameObject;
			BlastAttack.teamIndex = ((EntityState)this).teamComponent.teamIndex;
			BlastAttack.crit = ((BaseState)this).RollCrit();
			BlastAttack.procChainMask = default(ProcChainMask);
			BlastAttack.procCoefficient = SeamstressConfig.explodeProcCoefficient.Value;
			BlastAttack.falloffModel = (FalloffModel)1;
			BlastAttack.damageColorIndex = (DamageColorIndex)0;
			((EntityState)this).skillLocator.utility.UnsetSkillOverride((object)((EntityState)this).gameObject, SeamstressSurvivor.explodeSkillDef, (SkillOverridePriority)4);
			((EntityState)this).PlayCrossfade("FullBody, Override", "RipHeart", "Dash.playbackRate", baseDuration / ((BaseState)this).attackSpeedStat * 1.8f, baseDuration / ((BaseState)this).attackSpeedStat * 0.05f);
			Util.PlayAttackSpeedSound("Play_imp_overlord_attack2_tell", ((EntityState)this).gameObject, ((BaseState)this).attackSpeedStat);
			if (NetworkServer.active)
			{
				((EntityState)this).characterBody.AddBuff(Buffs.Slow50);
				((EntityState)this).characterBody.AddBuff(Buffs.SmallArmorBoost);
			}
		}

		public override void FixedUpdate()
		{
			base.FixedUpdate();
			if (((EntityState)this).isAuthority && ((EntityState)this).fixedAge >= baseDuration / ((BaseState)this).attackSpeedStat)
			{
				((EntityState)this).outer.SetNextStateToMain();
			}
		}

		public override void OnExit()
		{
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Expected O, but got Unknown
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Expected O, but got Unknown
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: 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)
			if (NetworkServer.active)
			{
				DotController val = DotController.FindDotController(((EntityState)this).gameObject);
				if (Object.op_Implicit((Object)(object)val))
				{
					for (int num = val.dotStackList.Count - 1; num >= 0; num--)
					{
						if (val.dotStackList[num].dotIndex == SeamstressDots.SeamstressSelfBleed)
						{
							val.RemoveDotStackAtServer(num);
						}
					}
				}
				((EntityState)this).characterBody.ClearTimedBuffs(SeamstressBuffs.SeamstressInsatiableBuff);
				((EntityState)this).characterBody.RemoveBuff(Buffs.Slow50);
				((EntityState)this).characterBody.RemoveBuff(Buffs.SmallArmorBoost);
				CleanseSystem.CleanseBodyServer(((EntityState)this).characterBody, false, false, false, true, false, false);
			}
			Util.PlaySound("Play_imp_overlord_teleport_end", ((EntityState)this).gameObject);
			if (((EntityState)this).isAuthority)
			{
				BlastAttack.Fire();
			}
			if (NetworkServer.active)
			{
				float barrier = ((EntityState)this).characterBody.healthComponent.barrier;
				((EntityState)this).characterBody.healthComponent.SetBarrier(0f);
				((EntityState)this).characterBody.healthComponent.Heal(barrier, default(ProcChainMask), true);
			}
			EffectManager.SpawnEffect(SeamstressAssets.genericImpactExplosionEffect, new EffectData
			{
				origin = ((EntityState)this).characterBody.corePosition,
				rotation = Quaternion.identity,
				color = Color32.op_Implicit(SeamstressAssets.coolRed)
			}, true);
			EffectManager.SpawnEffect(SeamstressAssets.slamEffect, new EffectData
			{
				origin = ((EntityState)this).characterBody.corePosition,
				rotation = Quaternion.identity
			}, true);
			((EntityState)this).OnExit();
		}
	}
	public class FireScissors : BaseSeamstressSkillState
	{
		public GameObject scissorFiringPrefab = SeamstressAssets.impDashEffect;

		private GameObject projectilePrefab;

		public static float baseDuration = 0.2f;

		public static string attackSoundString = "Play_imp_overlord_attack1_throw";

		private Animator modelAnimator;

		private float duration;

		private string chosenAnim = "FireScissorL";

		private bool hasFired;

		private Ray aimRay;

		private string fireString;

		protected virtual bool sceptered => false;

		public override void OnEnter()
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Expected O, but got Unknown
			RefreshState();
			if (seamstressController.blue)
			{
				scissorFiringPrefab = SeamstressAssets.impDashEffect2;
			}
			base.OnEnter();
			Util.PlaySound("Play_item_lunar_specialReplace_explode", ((EntityState)this).gameObject);
			((Component)((EntityState)this).characterBody).GetComponent<ScissorsControllerComponent>().isRight = true;
			duration = baseDuration / ((BaseState)this).attackSpeedStat;
			aimRay = ((BaseState)this).GetAimRay();
			((BaseState)this).StartAimMode(aimRay, 2f, false);
			modelAnimator = ((EntityState)this).GetModelAnimator();
			if (Object.op_Implicit((Object)(object)modelAnimator))
			{
				if (scissorRight && scissorLeft)
				{
					chosenAnim = "FireScissorL";
				}
				else if (scissorRight && !scissorLeft)
				{
					chosenAnim = "FireScissorR";
				}
				else if (scissorLeft && !scissorRight)
				{
					chosenAnim = "FireScissorL";
				}
				else
				{
					chosenAnim = "FireScissorL";
				}
				((EntityState)this).PlayCrossfade("Gesture, Override", chosenAnim, "Slash.playbackRate", duration * 2f, 0.05f);
			}
			if (NetworkServer.active)
			{
				DamageInfo val = new DamageInfo
				{
					damage = ((EntityState)this).characterBody.healthComponent.fullCombinedHealth * SeamstressConfig.scissorHealthCostCoefficient.Value,
					damageType = DamageTypeCombo.op_Implicit((DamageType)3),
					position = ((EntityState)this).characterBody.corePosition,
					attacker = null,
					procCoefficient = 0f,
					crit = false,
					damageColorIndex = (DamageColorIndex)2
				};
				((EntityState)this).characterBody.healthComponent.TakeDamage(val);
			}
		}

		public override void OnExit()
		{
			RefreshState();
			((EntityState)this).OnExit();
		}

		public override void FixedUpdate()
		{
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			base.FixedUpdate();
			if (Object.op_Implicit((Object)(object)modelAnimator) && !hasFired)
			{
				if (chosenAnim == "FireScissorL")
				{
					projectilePrefab = seamstressController.scissorLPrefab;
					fireString = "SwingRightSmall";
				}
				else
				{
					projectilePrefab = seamstressController.scissorRPrefab;
					fireString = "SwingLeftSmall";
				}
				float num = (sceptered ? 0.75f : SeamstressConfig.basePickupCooldown.Value);
				((Component)projectilePrefab.transform.GetChild(0).GetChild(5)).gameObject.GetComponent<ScissorsPickupFilterComponent>().pickupTimer = Mathf.Max(0.5f, num * ((EntityState)this).skillLocator.special.cooldownScale - ((EntityState)this).skillLocator.special.flatCooldownReduction);
				if (isInsatiable)
				{
					DamageAPI.AddModdedDamageType(ref projectilePrefab.GetComponent<ProjectileDamage>().damageType, DamageTypes.CutDamage);
				}
				else if (DamageAPI.HasModdedDamageType(ref projectilePrefab.GetComponent<ProjectileDamage>().damageType, DamageTypes.CutDamage))
				{
					DamageAPI.RemoveModdedDamageType(ref projectilePrefab.GetComponent<ProjectileDamage>().damageType, DamageTypes.CutDamage);
				}
				Fire(aimRay, fireString);
				hasFired = true;
			}
			if (((EntityState)this).fixedAge >= duration && ((EntityState)this).isAuthority)
			{
				((EntityState)this).outer.SetNextStateToMain();
			}
		}

		private void Fire(Ray aimRay, string muzzleName)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: 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)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			Util.PlaySound(attackSoundString, ((EntityState)this).gameObject);
			Transform val = ((BaseState)this).FindModelChild(muzzleName);
			if (Object.op_Implicit((Object)(object)val))
			{
				EffectData val2 = new EffectData();
				val2.rotation = Util.QuaternionSafeLookRotation(((Ray)(ref aimRay)).direction);
				val2.origin = val.position;
				val2.scale = 0.5f;
				EffectManager.SpawnEffect(scissorFiringPrefab, val2, true);
			}
			if (((EntityState)this).isAuthority)
			{
				ProjectileManager.instance.FireProjectile(projectilePrefab, ((Ray)(ref aimRay)).origin, Util.QuaternionSafeLookRotation(((Ray)(ref aimRay)).direction), ((EntityState)this).gameObject, ((BaseState)this).damageStat, 0f, Util.CheckRoll(((BaseState)this).critStat, ((EntityState)this).characterBody.master), (DamageColorIndex)0, (GameObject)null, -1f, (DamageTypeCombo?)null);
				if (Object.op_Implicit((Object)(object)((EntityState)this).characterMotor) && !((EntityState)this).characterMotor.isGrounded)
				{
					CharacterMotor characterMotor = ((EntityState)this).characterMotor;
					Vector3 velocity = characterMotor.velocity;
					Vector3 direction = ((Ray)(ref aimRay)).direction;
					characterMotor.velocity = velocity - ((Vector3)(ref direction)).normalized * SeamstressConfig.skewerAirRecoilSpeed.Value;
				}
			}
		}

		public override InterruptPriority GetMinimumInterruptPriority()
		{
			//IL_0002: 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)
			return (InterruptPriority)2;
		}
	}
	public class FireScissorsScepter : FireScissors
	{
		protected override bool sceptered => true;
	}
	public class Flurry : BaseMeleeAttack
	{
		public override void OnEnter()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			RefreshState();
			hitboxGroupName = "Sword";
			damageType = (DamageType)0;
			damageSource = (DamageSource)1;
			damageTotal = SeamstressConfig.flurryDamageCoefficient.Value;
			procCoefficient = SeamstressConfig.flurryProcCoefficient.Value;
			pushForce = 300f;
			bonusForce = Vector3.zero;
			baseDuration = 1.1f;
			baseScissorDuration = 2f;
			attackStartPercentTime = 0.2f;
			attackEndPercentTime = 0.4f;
			earlyExitPercentTime = 0.5f;
			hitStopDuration = 0.05f;
			attackRecoil = 2f / ((BaseState)this).attackSpeedStat;
			hitHopVelocity = 8f;
			swingSoundString = "sfx_seamstress_swing";
			hitSoundString = "";
			hitEffectPrefab = (seamstressController.blue ? SeamstressAssets.scissorsHitImpactEffect2 : SeamstressAssets.scissorsHitImpactEffect);
			swingEffectPrefab = (seamstressController.blue ? SeamstressAssets.clawSlashEffect2 : SeamstressAssets.clawSlashEffect);
			bonusSwingEffectPrefab = (seamstressController.blue ? SeamstressAssets.scissorsSlashEffect2 : SeamstressAssets.scissorsSlashEffect);
			muzzleString = ((swingIndex % 2 == 0) ? "SwingLeftSmall" : "SwingRightSmall");
			buffer = false;
			if (isInsatiable)
			{
				moddedDamageTypeHolder.Add(DamageTypes.CutDamage);
				moddedDamageTypeHolder.Add(DamageTypes.GainNeedles);
			}
			moddedDamageTypeHolder.Add(DamageTypes.SeamstressLifesteal);
			scissorHit = true;
			if (muzzleString == "SwingLeftSmall" && !scissorRight)
			{
				scissorHit = false;
			}
			if (muzzleString == "SwingRightSmall" && !scissorLeft)
			{
				scissorHit = false;
			}
			impactSound = SeamstressAssets.scissorsHitSoundEvent.index;
			base.OnEnter();
		}

		public override void FixedUpdate()
		{
			base.FixedUpdate();
		}

		protected override void FireAttack()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			if (((EntityState)this).isAuthority)
			{
				Ray aimRay = ((BaseState)this).GetAimRay();
				Vector3 direction = ((Ray)(ref aimRay)).direction;
				direction.y = Mathf.Max(direction.y, direction.y * 0.5f);
				((BaseState)this).FindModelChild("SwingPivot").rotation = Util.QuaternionSafeLookRotation(direction);
				if (attack.Fire((List<HurtBox>)null))
				{
					OnHitEnemyAuthority();
				}
			}
		}

		protected override void PlayAttackAnimation()
		{
			((EntityState)this).PlayCrossfade("Gesture, Override", (swingIndex % 2 == 0) ? "Slash1" : "Slash2", "Slash.playbackRate", duration, 0.1f * duration);
		}

		protected override void OnHitEnemyAuthority()
		{
			base.OnHitEnemyAuthority();
		}

		public override void OnExit()
		{
			base.OnExit();
		}
	}
	public class HealthCostDash : BaseSeamstressSkillState
	{
		public float baseDuration = 0.8f;

		public float dashPower = 6f;

		public float damageCoefficient;

		public GameObject uppercutEffect = SeamstressAssets.uppercutEffect;

		public GameObject projectilePrefab = SeamstressAssets.heartPrefab;

		public GameObject scissorHitImpactEffect = SeamstressAssets.scissorsHitImpactEffect;

		public GameObject bloodExplosionEffect = SeamstressAssets.bloodExplosionEffect;

		public GameObject impDashEffect = SeamstressAssets.impDashEffect;

		public GameObject bloodSplatterEffect = SeamstressAssets.bloodSplatterEffect;

		public GameObject smallBlinkEffect = SeamstressAssets.smallBlinkEffect;

		public Color mainColor = SeamstressAssets.coolRed;

		public Material destealthMaterial = SeamstressAssets.destealthMaterial;

		private Vector3 dashVector;

		private OverlapAttack attack;

		private List<HurtBox> victimsStruck = new List<HurtBox>();

		protected string hitBoxString = "Sword";

		private bool hasHit;

		private bool hasDelayed;

		private float insatiableDuration;

		public override void OnEnter()
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			RefreshState();
			damageCoefficient = SeamstressConfig.blinkDamageCoefficient.Value;
			insatiableDuration = SeamstressConfig.insatiableDuration.Value;
			if (seamstressController.blue)
			{
				uppercutEffect = SeamstressAssets.uppercutEffect2;
				projectilePrefab = SeamstressAssets.heartPrefab2;
				scissorHitImpactEffect = SeamstressAssets.scissorsHitImpactEffect2;
				bloodExplosionEffect = SeamstressAssets.bloodExplosionEffect2;
				impDashEffect = SeamstressAssets.impDashEffect2;
				bloodSplatterEffect = SeamstressAssets.bloodSplatterEffect2;
				smallBlinkEffect = SeamstressAssets.smallBlinkEffect2;
				mainColor = Color.cyan;
				destealthMaterial = SeamstressAssets.destealthMaterial2;
			}
			base.OnEnter();
			((EntityState)this).characterMotor.disableAirControlUntilCollision = false;
			Transform modelTransform = ((EntityState)this).GetModelTransform();
			Animator component = ((Component)modelTransform).GetComponent<Animator>();
			if (Object.op_Implicit((Object)(object)modelTransform) && Object.op_Implicit((Object)(object)destealthMaterial))
			{
				TemporaryOverlayInstance val = TemporaryOverlayManager.AddOverlay(((EntityState)this).gameObject);
				val.duration = 1.2f;
				val.destroyComponentOnEnd = true;
				val.originalMaterial = destealthMaterial;
				val.inspectorCharacterModel = ((Component)component).gameObject.GetComponent<CharacterModel>();
				val.alphaCurve = AnimationCurve.EaseInOut(0f, 1f, 1f, 0f);
				val.animateShaderAlpha = true;
			}
			((EntityState)this).characterMotor.velocity = Vector3.zero;
			((EntityState)this).PlayCrossfade("FullBody, Override", "RipHeart", "Dash.playbackRate", baseDuration / ((BaseState)this).attackSpeedStat * 1.8f, baseDuration / ((BaseState)this).attackSpeedStat * 0.05f);
			Util.PlayAttackSpeedSound("Play_imp_overlord_attack2_tell", ((EntityState)this).gameObject, ((BaseState)this).attackSpeedStat);
		}

		public override void FixedUpdate()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Expected O, but got Unknown
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02be: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d4: Expected O, but got Unknown
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Expected O, but got Unknown
			//IL_0088: 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_02fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0305: Unknown result type (might be due to invalid IL or missing references)
			//IL_030a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0311: Unknown result type (might be due to invalid IL or missing references)
			//IL_031c: Unknown result type (might be due to invalid IL or missing references)
			//IL_031e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0323: Unknown result type (might be due to invalid IL or missing references)
			//IL_0328: Unknown result type (might be due to invalid IL or missing references)
			//IL_032d: Unknown result type (might be due to invalid IL or missing references)
			//IL_033a: Expected O, but got Unknown
			//IL_0374: Unknown result type (might be due to invalid IL or missing references)
			//IL_037a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0392: Unknown result type (might be due to invalid IL or missing references)
			//IL_0397: Unknown result type (might be due to invalid IL or missing references)
			//IL_039c: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0400: Unknown result type (might be due to invalid IL or missing references)
			//IL_0402: Unknown result type (might be due to invalid IL or missing references)
			//IL_0407: Unknown result type (might be due to invalid IL or missing references)
			//IL_040c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0417: Expected O, but got Unkn