using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("CombatFlow.Core")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.1.1.0")]
[assembly: AssemblyInformationalVersion("0.1.1+ae7cbc76414b0819a0294580cc820e6d873af136")]
[assembly: AssemblyProduct("CombatFlow.Core")]
[assembly: AssemblyTitle("CombatFlow.Core")]
[assembly: AssemblyVersion("0.1.1.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	internal static class IsExternalInit
	{
	}
}
namespace CombatFlow.Core
{
	public static class AttackClassifier
	{
		public static AttackKind Classify(string? attackAnimation)
		{
			return attackAnimation switch
			{
				"swing_longsword" => AttackKind.SwordCombo, 
				"sword_secondary" => AttackKind.SwordSecondary, 
				"dualaxes" => AttackKind.AxesCombo, 
				"dualaxes_secondary" => AttackKind.AxesSecondary, 
				_ => AttackKind.None, 
			};
		}
	}
	public static class AttackClear
	{
		public const float Window = 0.1f;

		public const float Never = float.NegativeInfinity;

		public static bool Unexplained(float now, float lastSeen)
		{
			return now - lastSeen > 0.1001f;
		}

		public static string Callers(IEnumerable<(string? ns, string? type, string? method)> frames, int max)
		{
			StringBuilder stringBuilder = new StringBuilder();
			int num = 0;
			foreach (var (ns, text, text2) in frames)
			{
				if (num >= max)
				{
					break;
				}
				if (!string.IsNullOrEmpty(text) && !string.IsNullOrEmpty(text2) && !Skipped(ns) && !text.StartsWith("DMD<", StringComparison.Ordinal) && !text2.StartsWith("DMD<", StringComparison.Ordinal))
				{
					if (num > 0)
					{
						stringBuilder.Append('>');
					}
					stringBuilder.Append(text).Append('.').Append(text2);
					num++;
				}
			}
			if (num != 0)
			{
				return stringBuilder.ToString();
			}
			return "-";
		}

		private static bool Skipped(string? ns)
		{
			if (ns != null)
			{
				if (!Starts(ns, "CombatFlow") && !Starts(ns, "HarmonyLib"))
				{
					return Starts(ns, "MonoMod");
				}
				return true;
			}
			return false;
		}

		private static bool Starts(string ns, string root)
		{
			if (!(ns == root))
			{
				return ns.StartsWith(root + ".", StringComparison.Ordinal);
			}
			return true;
		}
	}
	public enum AttackKind
	{
		None,
		SwordCombo,
		SwordSecondary,
		AxesCombo,
		AxesSecondary
	}
	public static class AutoParry
	{
		public const string Force = "force";

		public const float PerfectBlockTimer = 0f;

		public static bool IsOn(CancelSettings s)
		{
			if (s.Enabled)
			{
				return s.AutoParry;
			}
			return false;
		}

		public static bool FromFront(float dotDirForward)
		{
			return !(dotDirForward > 0f);
		}

		public static bool ShouldForce(bool enabled, bool autoParry, bool isLocalPlayer, bool blockable, bool fromFront, bool hasBlocker, bool inDodge, bool inPlaceMode, bool encumbered, bool inMinorAction, bool staggering)
		{
			return Decide(enabled, autoParry, isLocalPlayer, blockable, fromFront, hasBlocker, inDodge, inPlaceMode, encumbered, inMinorAction, staggering) == "force";
		}

		public static string Decide(bool enabled, bool autoParry, bool isLocalPlayer, bool blockable, bool fromFront, bool hasBlocker, bool inDodge, bool inPlaceMode, bool encumbered, bool inMinorAction, bool staggering)
		{
			if (!enabled || !autoParry)
			{
				return "off";
			}
			if (!isLocalPlayer)
			{
				return "not_local";
			}
			if (!blockable)
			{
				return "not_blockable";
			}
			if (!fromFront)
			{
				return "behind";
			}
			if (!hasBlocker)
			{
				return "no_blocker";
			}
			if (inDodge)
			{
				return "dodge";
			}
			if (inPlaceMode)
			{
				return "place_mode";
			}
			if (encumbered)
			{
				return "encumbered";
			}
			if (inMinorAction)
			{
				return "minor_action";
			}
			if (staggering)
			{
				return "staggering";
			}
			return "force";
		}

		public static bool ForcedBlocking(bool inDodge, bool inPlaceMode, bool encumbered, bool inMinorAction, bool staggering)
		{
			if (!inDodge && !inPlaceMode && !encumbered && !inMinorAction)
			{
				return !staggering;
			}
			return false;
		}

		public static string Outcome(float timedBlockBonus, bool guardBroken, bool hasAttacker)
		{
			if (guardBroken)
			{
				return "guard_broken";
			}
			if (!(timedBlockBonus > 1f && hasAttacker))
			{
				return "blocked";
			}
			return "perfect";
		}
	}
	public static class CancelEmotes
	{
		public static string Trigger(CancelEmote e)
		{
			if (e != CancelEmote.Cheer)
			{
				return "emote_nonono";
			}
			return "emote_cheer";
		}

		public static float BlendSeconds(CancelEmote e)
		{
			if (e != CancelEmote.Cheer)
			{
				return 0.11f;
			}
			return 0.19f;
		}
	}
	public readonly struct CancelDecision
	{
		public bool Cancel { get; }

		public string Reason { get; }

		public CancelDecision(bool cancel, string reason)
		{
			Cancel = cancel;
			Reason = reason;
		}
	}
	public static class CancelPolicy
	{
		public static CancelDecision ShouldCancel(AttackKind kind, ClipTiming timing, int damageEventsSeen, float stateSpeed, CancelSettings s)
		{
			if (!s.Enabled)
			{
				return new CancelDecision(cancel: false, "disabled");
			}
			if (kind == AttackKind.None)
			{
				return new CancelDecision(cancel: false, "not_handled");
			}
			IReadOnlyList<float> damageEventTimes = timing.DamageEventTimes;
			if (damageEventTimes.Count == 0 || damageEventsSeen != damageEventTimes.Count)
			{
				return new CancelDecision(cancel: false, "not_last_hit");
			}
			float? chainTime = timing.ChainTime;
			if (chainTime.HasValue)
			{
				float valueOrDefault = chainTime.GetValueOrDefault();
				if (!(damageEventTimes[damageEventTimes.Count - 1] + CancelEmotes.BlendSeconds(s.Emote) * stateSpeed < valueOrDefault))
				{
					return new CancelDecision(cancel: false, "chain_faster");
				}
			}
			return new CancelDecision(cancel: true, "ok");
		}

		public static CancelDecision ShouldFireDelayed(bool enabled, bool sameAttack, bool staggering, bool inAttack)
		{
			if (!enabled)
			{
				return new CancelDecision(cancel: false, "disabled");
			}
			if (!sameAttack || staggering || !inAttack)
			{
				return new CancelDecision(cancel: false, "superseded");
			}
			return new CancelDecision(cancel: true, "ok");
		}

		public static CancelDecision ShouldFireNow(CancelDecision d, bool staggering)
		{
			if (!(d.Cancel && staggering))
			{
				return d;
			}
			return new CancelDecision(cancel: false, "superseded");
		}

		public static CancelDecision ShouldCancelDodge(CancelSettings s)
		{
			if (!s.Enabled)
			{
				return new CancelDecision(cancel: false, "disabled");
			}
			if (!s.Dodge)
			{
				return new CancelDecision(cancel: false, "toggle_off");
			}
			return new CancelDecision(cancel: true, "ok");
		}
	}
	public enum CancelEmote
	{
		NoNoNo,
		Cheer
	}
	public enum MaxComboMode
	{
		Cycle,
		Loop
	}
	public sealed record CancelSettings(bool Enabled, bool Dodge, CancelEmote Emote, float DelayAfterHit, bool DebugLog, bool MaxCombo = false, MaxComboMode MaxComboMode = MaxComboMode.Cycle, int MaxComboLoopCap = 0, bool SwapButtons = false, bool AutoParry = false, bool AxesMaxCombo = false)
	{
		public static CancelSettings Default { get; } = new CancelSettings(Enabled: true, Dodge: true, CancelEmote.NoNoNo, 0f, DebugLog: false, MaxCombo: true, MaxComboMode.Loop, 0, SwapButtons: false, AutoParry: false, AxesMaxCombo: true);

		[CompilerGenerated]
		private CancelSettings(CancelSettings original)
		{
			Enabled = original.Enabled;
			Dodge = original.Dodge;
			Emote = original.Emote;
			DelayAfterHit = original.DelayAfterHit;
			DebugLog = original.DebugLog;
			MaxCombo = original.MaxCombo;
			MaxComboMode = original.MaxComboMode;
			MaxComboLoopCap = original.MaxComboLoopCap;
			SwapButtons = original.SwapButtons;
			AutoParry = original.AutoParry;
			AxesMaxCombo = original.AxesMaxCombo;
		}
	}
	public enum ClipPickResult
	{
		Current,
		Next,
		Ambiguous
	}
	public static class ClipPick
	{
		public const float Tolerance = 0.05f;

		public static ClipPickResult Choose(ClipTiming? current, float currentT, float currentLength, ClipTiming? next, float nextT, float nextLength)
		{
			if (next == null)
			{
				return ClipPickResult.Current;
			}
			if (current == null)
			{
				return ClipPickResult.Next;
			}
			bool flag = HasDamageNear(current, currentT, currentLength);
			bool flag2 = HasDamageNear(next, nextT, nextLength);
			if (flag == flag2)
			{
				return ClipPickResult.Ambiguous;
			}
			if (!flag)
			{
				return ClipPickResult.Next;
			}
			return ClipPickResult.Current;
		}

		public static bool UseNext(ClipPickResult r)
		{
			return r == ClipPickResult.Next;
		}

		public static bool HasDamageNear(ClipTiming t, float clipT, float clipLength, float tolerance = 0.05f)
		{
			foreach (float damageEventTime in t.DamageEventTimes)
			{
				float num = Math.Abs(damageEventTime - clipT);
				if (clipLength > 0f)
				{
					num %= clipLength;
					num = Math.Min(num, clipLength - num);
				}
				if (num <= tolerance + 0.0001f)
				{
					return true;
				}
			}
			return false;
		}

		public static string LogValue(ClipPickResult r)
		{
			return r switch
			{
				ClipPickResult.Next => "next", 
				ClipPickResult.Ambiguous => "ambiguous", 
				_ => "current", 
			};
		}
	}
	public sealed class ClipTiming
	{
		public IReadOnlyList<float> DamageEventTimes { get; }

		public float? ChainTime { get; }

		public ClipTiming(IReadOnlyList<float> damageEventTimes, float? chainTime)
		{
			DamageEventTimes = damageEventTimes;
			ChainTime = chainTime;
		}

		public static ClipTiming FromEvents(IEnumerable<(float time, string functionName)> events)
		{
			List<float> list = new List<float>();
			float? num = null;
			foreach (var @event in events)
			{
				var (num2, _) = @event;
				switch (@event.functionName)
				{
				case "Hit":
				case "OnAttackTrigger":
					list.Add(num2);
					break;
				case "Chain":
					if (!num.HasValue || num2 < num)
					{
						num = num2;
					}
					break;
				}
			}
			list.Sort();
			return new ClipTiming(list, num);
		}
	}
	public sealed class DamageCounter
	{
		private object? _current;

		private int _seen;

		public int Register(object attackInstance)
		{
			if (attackInstance != _current)
			{
				_current = attackInstance;
				_seen = 0;
			}
			return ++_seen;
		}
	}
	public static class DebugLine
	{
		public static string Format(double t, int frame, string ev, IReadOnlyList<(string k, string v)> kv)
		{
			StringBuilder stringBuilder = new StringBuilder(64);
			stringBuilder.Append("AC t=").Append(t.ToString("0.000", CultureInfo.InvariantCulture)).Append(" f=")
				.Append(frame.ToString(CultureInfo.InvariantCulture))
				.Append(" ev=")
				.Append(ev);
			for (int i = 0; i < kv.Count; i++)
			{
				stringBuilder.Append(' ').Append(kv[i].k).Append('=')
					.Append(Token(kv[i].v));
			}
			return stringBuilder.ToString();
		}

		public static string Num(double v)
		{
			return v.ToString("0.###", CultureInfo.InvariantCulture);
		}

		public static string Bool(bool b)
		{
			if (!b)
			{
				return "false";
			}
			return "true";
		}

		private static string Token(string? v)
		{
			if (!string.IsNullOrEmpty(v))
			{
				return v.Replace(' ', '_');
			}
			return "-";
		}
	}
	public static class HoldDrop
	{
		public const float WatchWindow = 0.5f;

		public static bool ShouldWatch(bool inFlight, float now, float lastCancelTime)
		{
			if (!inFlight)
			{
				if (now - lastCancelTime >= 0f)
				{
					return now - lastCancelTime <= 0.5f;
				}
				return false;
			}
			return true;
		}

		public static bool WasDropped(bool incomingHold, bool holdAfter)
		{
			if (incomingHold)
			{
				return !holdAfter;
			}
			return false;
		}
	}
	public static class LabLine
	{
		public static string Format(double t, int frame, int ff, string ev, IReadOnlyList<(string k, string v)> kv)
		{
			StringBuilder stringBuilder = new StringBuilder(80);
			stringBuilder.Append("CL t=").Append(t.ToString("0.000", CultureInfo.InvariantCulture)).Append(" f=")
				.Append(frame.ToString(CultureInfo.InvariantCulture))
				.Append(" ff=")
				.Append(ff.ToString(CultureInfo.InvariantCulture))
				.Append(" ev=")
				.Append(ev);
			for (int i = 0; i < kv.Count; i++)
			{
				stringBuilder.Append(' ').Append(kv[i].k).Append('=')
					.Append(Token(kv[i].v));
			}
			return stringBuilder.ToString();
		}

		public static string Dp(double v, int decimals)
		{
			return v.ToString("F" + decimals.ToString(CultureInfo.InvariantCulture), CultureInfo.InvariantCulture);
		}

		public static string Bit(bool b)
		{
			if (!b)
			{
				return "0";
			}
			return "1";
		}

		public static bool IsLastChain(int lvl, int levels)
		{
			if (levels > 1)
			{
				return lvl == levels - 1;
			}
			return false;
		}

		public static float SwingMultiplier(float damageMultiplier, float lastChainMultiplier, int lvl, int levels)
		{
			if (!IsLastChain(lvl, levels) || !(lastChainMultiplier > 1f))
			{
				return damageMultiplier;
			}
			return damageMultiplier * lastChainMultiplier;
		}

		public static int InputMask(bool attack, bool attackHold, bool secondary, bool secondaryHold, bool block, bool blockHold)
		{
			return (int)((attack ? 1u : 0u) | (uint)(attackHold ? 2 : 0) | (uint)(secondary ? 4 : 0) | (uint)(secondaryHold ? 8 : 0) | (uint)(block ? 16 : 0)) | (blockHold ? 32 : 0);
		}

		public static string TagName(int tag, int attack, int emote, int dodge, int idle)
		{
			if (tag == attack)
			{
				return "attack";
			}
			if (tag == emote)
			{
				return "emote";
			}
			if (tag == dodge)
			{
				return "dodge";
			}
			if (tag == idle)
			{
				return "idle";
			}
			return "other";
		}

		private static string Token(string? v)
		{
			if (!string.IsNullOrEmpty(v))
			{
				return v.Replace(' ', '_');
			}
			return "-";
		}
	}
	public enum LogKind
	{
		Review,
		Lab,
		Info
	}
	public static class LogGate
	{
		public const bool ComboLabLogDefault = false;

		public static bool Allows(LogKind kind, bool debugLog, bool comboLabLog)
		{
			if (debugLog)
			{
				return kind != LogKind.Lab || comboLabLog;
			}
			return false;
		}
	}
	public enum MaxComboActionKind
	{
		None,
		TriggerSwing1,
		TriggerSwing2,
		CancelNow,
		Abort,
		Progress
	}
	public readonly struct MaxComboAction
	{
		public MaxComboActionKind Kind { get; }

		public string Reason { get; }

		public static MaxComboAction None => new MaxComboAction(MaxComboActionKind.None, "");

		public static MaxComboAction TriggerSwing1 => new MaxComboAction(MaxComboActionKind.TriggerSwing1, "");

		public static MaxComboAction TriggerSwing2 => new MaxComboAction(MaxComboActionKind.TriggerSwing2, "");

		public static MaxComboAction CancelNow => new MaxComboAction(MaxComboActionKind.CancelNow, "");

		public static MaxComboAction Progress => new MaxComboAction(MaxComboActionKind.Progress, "");

		private MaxComboAction(MaxComboActionKind kind, string reason)
		{
			Kind = kind;
			Reason = reason;
		}

		public static MaxComboAction Abort(string reason)
		{
			return new MaxComboAction(MaxComboActionKind.Abort, reason);
		}

		public static MaxComboAction End(string reason)
		{
			return new MaxComboAction(MaxComboActionKind.CancelNow, reason);
		}
	}
	public sealed record MaxComboState(int Step, int InstanceId, float StepTime, int Loop = 0)
	{
		public static MaxComboState Idle { get; } = new MaxComboState(0, 0, 0f);

		public bool Running => Step > 0;

		[CompilerGenerated]
		private MaxComboState(MaxComboState original)
		{
			Step = original.Step;
			InstanceId = original.InstanceId;
			StepTime = original.StepTime;
			Loop = original.Loop;
		}
	}
	public static class MaxComboPolicy
	{
		public const float Timeout = 1f;

		public const int DefaultLoopCap = 0;

		public const int MinLoopCap = 0;

		public const int MaxLoopCap = 1000;

		public const string SecondaryAnimation = "sword_secondary";

		public const string PrimaryAnimation = "swing_longsword";

		public const int MinPrimaryLevels = 3;

		public const string SecondaryClip = "Sword-Attack-R4";

		public const string Swing1Clip = "Attack2";

		public const string Swing2Clip = "Attack3";

		public const string Swing1Trigger = "swing_longsword1";

		public const string Swing2Trigger = "swing_longsword2";

		public static readonly string[] SwingTriggers = new string[3] { "swing_longsword0", "swing_longsword1", "swing_longsword2" };

		public static readonly string[] AbortTriggers = new string[2] { "swing_longsword1", "swing_longsword2" };

		public static bool Eligible(string? attackAnimation, string? primaryAnimation, int primaryChainLevels)
		{
			if (attackAnimation == "sword_secondary" && primaryAnimation == "swing_longsword")
			{
				return primaryChainLevels >= 3;
			}
			return false;
		}

		public static bool Eligible(MaxComboProfile profile, string? attackAnimation, int attackLevel, int attackLevels, string? primaryAnimation, int primaryLevels, string? secondaryAnimation)
		{
			return profile.Eligible(attackAnimation, attackLevel, attackLevels, primaryAnimation, primaryLevels, secondaryAnimation);
		}

		public static bool Routes(AttackKind kind, CancelSettings s, bool eligible)
		{
			return Routes(MaxComboProfile.Sword, kind, s, eligible);
		}

		public static bool Routes(MaxComboProfile profile, AttackKind kind, CancelSettings s, bool eligible)
		{
			return s.Enabled && profile.IsOn(s) && kind == profile.Kind && eligible;
		}

		public static bool Acts(MaxComboActionKind k)
		{
			if (k != MaxComboActionKind.TriggerSwing1 && k != MaxComboActionKind.TriggerSwing2 && k != MaxComboActionKind.CancelNow)
			{
				return k == MaxComboActionKind.Progress;
			}
			return true;
		}

		public static string SkipReason(MaxComboProfile profile, MaxComboState state, string? firedClip, int swingHit, CancelSettings s, bool eligible, bool staggering)
		{
			if (state.Running)
			{
				string expected = ((state.Step == 1) ? profile.Swing1Clip : profile.Swing2Clip);
				if (!MaxComboProfile.SameClip(firedClip, expected))
				{
					return "clip";
				}
				return "-";
			}
			if (!s.Enabled || !profile.IsOn(s))
			{
				return "off";
			}
			if (!eligible)
			{
				return "not_eligible";
			}
			if (staggering)
			{
				return "staggering";
			}
			if (!MaxComboProfile.SameClip(firedClip, profile.StartClip))
			{
				return "clip";
			}
			if (swingHit < profile.StartHits)
			{
				return "not_last_hit";
			}
			return "-";
		}

		public static (string k, string v)[] SkipFields(string reason, string? clip, int swingHit, int step)
		{
			int num = 0;
			string text = clip ?? "";
			for (int i = 0; i < text.Length; i++)
			{
				if (text[i] == ' ')
				{
					num++;
				}
			}
			return new(string, string)[5]
			{
				("reason", reason),
				("clip", string.IsNullOrEmpty(clip) ? "-" : clip),
				("clipSpaces", num.ToString(CultureInfo.InvariantCulture)),
				("hit", swingHit.ToString(CultureInfo.InvariantCulture)),
				("step", step.ToString(CultureInfo.InvariantCulture))
			};
		}

		public static MaxComboAction Decide(MaxComboState state, string? firedClip, bool sameInstance, CancelSettings s, float sinceLastStep, bool eligible, bool staggering, bool held = false)
		{
			return Decide(MaxComboProfile.Sword, state, firedClip, 1, sameInstance, s, sinceLastStep, eligible, staggering, held);
		}

		public static MaxComboAction Decide(MaxComboProfile profile, MaxComboState state, string? firedClip, int swingHit, bool sameInstance, CancelSettings s, float sinceLastStep, bool eligible, bool staggering, bool held = false)
		{
			bool flag = s.Enabled && profile.IsOn(s);
			if (state.Running)
			{
				MaxComboAction result = AbortReason(flag, sameInstance, staggering, dodging: false, sinceLastStep);
				if (result.Kind == MaxComboActionKind.Abort)
				{
					return result;
				}
				bool flag2 = s.MaxComboMode == MaxComboMode.Loop;
				if (state.Step == 1 && MaxComboProfile.SameClip(firedClip, profile.Swing1Clip))
				{
					if (swingHit < profile.Swing1Hits)
					{
						return MaxComboAction.Progress;
					}
					if (!flag2 || state.Loop <= 0)
					{
						return MaxComboAction.TriggerSwing2;
					}
					return LoopHit(state, s, held, MaxComboAction.TriggerSwing2);
				}
				if (state.Step == 2 && MaxComboProfile.SameClip(firedClip, profile.Swing2Clip))
				{
					if (swingHit < profile.Swing2Hits)
					{
						return MaxComboAction.Progress;
					}
					if (!flag2)
					{
						return MaxComboAction.CancelNow;
					}
					return LoopHit(state, s, held, MaxComboAction.TriggerSwing1);
				}
				return MaxComboAction.None;
			}
			if (!flag || !eligible || staggering || !MaxComboProfile.SameClip(firedClip, profile.StartClip) || swingHit < profile.StartHits)
			{
				return MaxComboAction.None;
			}
			return MaxComboAction.TriggerSwing1;
		}

		public static MaxComboAction Watch(MaxComboState state, bool sameInstance, CancelSettings s, float sinceLastStep, bool staggering, bool dodging)
		{
			return Watch(MaxComboProfile.Sword, state, sameInstance, s, sinceLastStep, staggering, dodging);
		}

		public static MaxComboAction Watch(MaxComboProfile profile, MaxComboState state, bool sameInstance, CancelSettings s, float sinceLastStep, bool staggering, bool dodging)
		{
			if (!state.Running)
			{
				return MaxComboAction.None;
			}
			return AbortReason(s.Enabled && profile.IsOn(s), sameInstance, staggering, dodging, sinceLastStep);
		}

		public static MaxComboState Next(MaxComboState state, MaxComboAction a, int instanceId, float now)
		{
			switch (a.Kind)
			{
			case MaxComboActionKind.TriggerSwing1:
				if (!state.Running)
				{
					return new MaxComboState(1, instanceId, now);
				}
				return new MaxComboState(1, state.InstanceId, now, state.Loop + 1);
			case MaxComboActionKind.TriggerSwing2:
				return new MaxComboState(2, state.InstanceId, now, (state.Loop > 0) ? (state.Loop + 1) : 0);
			case MaxComboActionKind.Progress:
				if (!state.Running)
				{
					return state;
				}
				return state with
				{
					StepTime = now
				};
			case MaxComboActionKind.CancelNow:
			case MaxComboActionKind.Abort:
				return MaxComboState.Idle;
			default:
				return state;
			}
		}

		public static int StepNumber(MaxComboActionKind k)
		{
			return k switch
			{
				MaxComboActionKind.TriggerSwing1 => 1, 
				MaxComboActionKind.TriggerSwing2 => 2, 
				MaxComboActionKind.CancelNow => 3, 
				_ => 0, 
			};
		}

		public static string? TriggerFor(MaxComboActionKind k)
		{
			return k switch
			{
				MaxComboActionKind.TriggerSwing1 => "swing_longsword1", 
				MaxComboActionKind.TriggerSwing2 => "swing_longsword2", 
				_ => null, 
			};
		}

		public static (string k, string v)[] StepFields(int step, string? clip, int instanceId)
		{
			return new(string, string)[3]
			{
				("step", step.ToString(CultureInfo.InvariantCulture)),
				("clip", string.IsNullOrEmpty(clip) ? "-" : clip),
				("attack", ShortId(instanceId))
			};
		}

		public static (string k, string v)[] RunFields(int loop, string? plan, float stamina)
		{
			return new(string, string)[3]
			{
				("loop", loop.ToString(CultureInfo.InvariantCulture)),
				("plan", string.IsNullOrEmpty(plan) ? "-" : plan),
				("stamina", stamina.ToString("0.0", CultureInfo.InvariantCulture))
			};
		}

		public static (string k, string v)[] WeaponFields(MaxComboProfile profile)
		{
			return new(string, string)[1] { ("weapon", profile.Weapon) };
		}

		public static (string k, string v)[] EndFields(string reason)
		{
			return new(string, string)[1] { ("reason", reason) };
		}

		public static (string k, string v)[] AbortFields(string reason)
		{
			return new(string, string)[1] { ("reason", reason) };
		}

		public static (string k, string v)[] ConfigFields(CancelSettings s)
		{
			return new(string, string)[5]
			{
				("enabled", DebugLine.Bool(s.Enabled)),
				("maxCombo", DebugLine.Bool(s.MaxCombo)),
				("maxComboMode", s.MaxComboMode.ToString()),
				("maxComboLoopCap", s.MaxComboLoopCap.ToString(CultureInfo.InvariantCulture)),
				("axesMaxCombo", DebugLine.Bool(s.AxesMaxCombo))
			};
		}

		public static string ShortId(int id)
		{
			return (id & 0xFFFF).ToString("x4", CultureInfo.InvariantCulture);
		}

		private static MaxComboAction LoopHit(MaxComboState state, CancelSettings s, bool held, MaxComboAction next)
		{
			if (!held)
			{
				return MaxComboAction.End("released");
			}
			if (s.MaxComboLoopCap > 0 && state.Loop >= s.MaxComboLoopCap)
			{
				return MaxComboAction.End("cap");
			}
			return next;
		}

		private static MaxComboAction AbortReason(bool on, bool sameInstance, bool staggering, bool dodging, float since)
		{
			if (!on)
			{
				return MaxComboAction.Abort("disabled");
			}
			if (!sameInstance)
			{
				return MaxComboAction.Abort("instance");
			}
			if (staggering)
			{
				return MaxComboAction.Abort("stagger");
			}
			if (dodging)
			{
				return MaxComboAction.Abort("dodge");
			}
			if (since > 1f)
			{
				return MaxComboAction.Abort("timeout");
			}
			return MaxComboAction.None;
		}
	}
	public sealed class MaxComboProfile
	{
		private readonly bool _axes;

		public const string AxesPrimaryAnimation = "dualaxes";

		public const string AxesSecondaryAnimation = "dualaxes_secondary";

		public const int AxesMinChainLevels = 4;

		public const string AxesFinisherClip = "DualAxes_Attack_4";

		public const string AxesSwing1Clip = "DualAxes_Attack_3_2";

		public string Weapon { get; }

		public AttackKind Kind { get; }

		public string StartClip { get; }

		public string Swing1Clip { get; }

		public string Swing2Clip { get; }

		public int StartHits { get; }

		public int Swing1Hits { get; }

		public int Swing2Hits { get; }

		public string Swing1Trigger { get; }

		public string Swing2Trigger { get; }

		public string[] SwingTriggers { get; }

		public string[] AbortTriggers { get; }

		public bool HoldPrimary { get; }

		public static MaxComboProfile Sword { get; } = new MaxComboProfile("sword", AttackKind.SwordSecondary, "Sword-Attack-R4", 1, "Attack2", 1, "Attack3", 1, "swing_longsword1", "swing_longsword2", MaxComboPolicy.SwingTriggers, holdPrimary: false, axes: false);

		public static MaxComboProfile Axes { get; } = new MaxComboProfile("axes", AttackKind.AxesCombo, "DualAxes_Attack_4", 2, "DualAxes_Attack_3_2", 2, "DualAxes_Attack_4", 2, "dualaxes2", "dualaxes3", new string[4] { "dualaxes0", "dualaxes1", "dualaxes2", "dualaxes3" }, holdPrimary: true, axes: true);

		private MaxComboProfile(string weapon, AttackKind kind, string startClip, int startHits, string swing1Clip, int swing1Hits, string swing2Clip, int swing2Hits, string swing1Trigger, string swing2Trigger, string[] swingTriggers, bool holdPrimary, bool axes)
		{
			Weapon = weapon;
			Kind = kind;
			StartClip = startClip;
			StartHits = startHits;
			Swing1Clip = swing1Clip;
			Swing1Hits = swing1Hits;
			Swing2Clip = swing2Clip;
			Swing2Hits = swing2Hits;
			Swing1Trigger = swing1Trigger;
			Swing2Trigger = swing2Trigger;
			SwingTriggers = swingTriggers;
			AbortTriggers = new string[2] { swing1Trigger, swing2Trigger };
			HoldPrimary = holdPrimary;
			_axes = axes;
		}

		public static MaxComboProfile? For(AttackKind kind)
		{
			return kind switch
			{
				AttackKind.SwordSecondary => Sword, 
				AttackKind.AxesCombo => Axes, 
				_ => null, 
			};
		}

		public static bool SameClip(string? fired, string expected)
		{
			if (!string.IsNullOrEmpty(fired) && fired.Length == expected.Length)
			{
				return string.Equals(fired.Replace(' ', '_'), expected.Replace(' ', '_'), StringComparison.Ordinal);
			}
			return false;
		}

		public bool IsOn(CancelSettings s)
		{
			if (!_axes)
			{
				return s.MaxCombo;
			}
			return s.AxesMaxCombo;
		}

		public string? TriggerFor(MaxComboActionKind k)
		{
			return k switch
			{
				MaxComboActionKind.TriggerSwing1 => Swing1Trigger, 
				MaxComboActionKind.TriggerSwing2 => Swing2Trigger, 
				_ => null, 
			};
		}

		internal bool Eligible(string? attackAnimation, int attackLevel, int attackLevels, string? primaryAnimation, int primaryLevels, string? secondaryAnimation)
		{
			if (!_axes)
			{
				return MaxComboPolicy.Eligible(attackAnimation, primaryAnimation, primaryLevels);
			}
			if (attackAnimation == "dualaxes" && primaryAnimation == "dualaxes" && secondaryAnimation == "dualaxes_secondary" && attackLevels >= 4)
			{
				return attackLevel == attackLevels - 1;
			}
			return false;
		}
	}
	public sealed class SwingHitCounter
	{
		private int _instance;

		private string? _clip;

		private int _count;

		public int Register(int instanceId, string? clip)
		{
			if (_count == 0 || instanceId != _instance || clip != _clip)
			{
				_instance = instanceId;
				_clip = clip;
				_count = 0;
			}
			return ++_count;
		}

		public void Reset()
		{
			_count = 0;
			_clip = null;
			_instance = 0;
		}
	}
	public enum RecoveryAction
	{
		None,
		Stop,
		Expire
	}
	public readonly struct RecoveryDecision
	{
		public RecoveryAction Action { get; }

		public string Reason { get; }

		public RecoveryDecision(RecoveryAction action, string reason)
		{
			Action = action;
			Reason = reason;
		}
	}
	public static class RecoveryPolicy
	{
		public const float HeldGrace = 0.1f;

		public const float Expiry = 1.5f;

		private static readonly RecoveryDecision Wait = new RecoveryDecision(RecoveryAction.None, "");

		public static RecoveryDecision Decide(bool inFlight, bool currentTagIsEmote, bool inTransition, bool attackHeld, float fullyInEmoteFor, float sinceCancel)
		{
			if (!inFlight)
			{
				return Wait;
			}
			bool flag = currentTagIsEmote && !inTransition;
			if (flag && !attackHeld)
			{
				return new RecoveryDecision(RecoveryAction.Stop, "released");
			}
			if (flag && fullyInEmoteFor > 0.1f)
			{
				return new RecoveryDecision(RecoveryAction.Stop, "held_timeout");
			}
			if (sinceCancel > 1.5f)
			{
				return new RecoveryDecision(flag ? RecoveryAction.Stop : RecoveryAction.Expire, "expired");
			}
			return Wait;
		}

		public static bool EmoteTriggerSpent(bool currentTagIsEmote, bool nextTagIsEmote)
		{
			return currentTagIsEmote || nextTagIsEmote;
		}

		public static bool StopOnDisable(bool inFlight, bool currentTagIsEmote, bool nextTagIsEmote)
		{
			if (inFlight)
			{
				return currentTagIsEmote || nextTagIsEmote;
			}
			return false;
		}
	}
	public static class RelaunchBlock
	{
		public const float Window = 0.5f;

		public static bool ShouldStart(float dtSinceCancel)
		{
			if (dtSinceCancel >= 0f)
			{
				return dtSinceCancel < 0.5f;
			}
			return false;
		}

		public static bool AttackBegun(bool inTransition, bool currentIsAttack, bool nextIsAttack, bool currentIsCancelled)
		{
			if (!inTransition)
			{
				if (currentIsAttack)
				{
					return !currentIsCancelled;
				}
				return false;
			}
			return nextIsAttack;
		}

		public static bool ShouldLift(bool active, float sinceCancel, bool layer0Attack)
		{
			if (active)
			{
				if (!layer0Attack && !(sinceCancel < 0f))
				{
					return sinceCancel >= 0.5f;
				}
				return true;
			}
			return false;
		}

		public static bool ShouldRefuse(bool isLocalPlayer, bool active, float sinceCancel, bool layer0Attack)
		{
			if (isLocalPlayer && active)
			{
				return !ShouldLift(active, sinceCancel, layer0Attack);
			}
			return false;
		}
	}
	public static class SpeedPlan
	{
		public static (bool setAnimatorSpeed, bool setPauseRestore) For(float pauseTimer)
		{
			if (!(pauseTimer > 0f))
			{
				return (setAnimatorSpeed: true, setPauseRestore: false);
			}
			return (setAnimatorSpeed: false, setPauseRestore: true);
		}
	}
	public static class SpeedSkip
	{
		public const float Window = 0.5f;

		public static bool ShouldSkip(int? cancelledState, int currentState, int nextState, float sinceCancel)
		{
			return ShouldSkip(cancelledState, relaunched: false, currentState, nextState, sinceCancel);
		}

		public static bool ShouldSkip(int? cancelledState, bool relaunched, int currentState, int nextState, float sinceCancel)
		{
			if (cancelledState.HasValue && sinceCancel <= 0.5f)
			{
				if (currentState != cancelledState.Value)
				{
					if (!relaunched)
					{
						return nextState == cancelledState.Value;
					}
					return false;
				}
				return true;
			}
			return false;
		}

		public static bool ShouldForget(int? cancelledState, int currentState, int nextState)
		{
			return ShouldForget(cancelledState, relaunched: false, currentState, nextState);
		}

		public static bool ShouldForget(int? cancelledState, bool relaunched, int currentState, int nextState)
		{
			if (cancelledState.HasValue && currentState != cancelledState.Value)
			{
				if (!relaunched)
				{
					return nextState != cancelledState.Value;
				}
				return true;
			}
			return false;
		}
	}
	public readonly struct AttackInputs : IEquatable<AttackInputs>
	{
		public bool Attack { get; }

		public bool AttackHold { get; }

		public bool Secondary { get; }

		public bool SecondaryHold { get; }

		public AttackInputs(bool attack, bool attackHold, bool secondary, bool secondaryHold)
		{
			Attack = attack;
			AttackHold = attackHold;
			Secondary = secondary;
			SecondaryHold = secondaryHold;
		}

		public AttackInputs Swapped()
		{
			return new AttackInputs(Secondary, SecondaryHold, Attack, AttackHold);
		}

		public bool Equals(AttackInputs o)
		{
			if (Attack == o.Attack && AttackHold == o.AttackHold && Secondary == o.Secondary)
			{
				return SecondaryHold == o.SecondaryHold;
			}
			return false;
		}

		public override bool Equals(object? obj)
		{
			if (obj is AttackInputs o)
			{
				return Equals(o);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return (int)((Attack ? 1u : 0u) | (uint)(AttackHold ? 2 : 0) | (uint)(Secondary ? 4 : 0)) | (SecondaryHold ? 8 : 0);
		}
	}
	public static class SwapButtons
	{
		public static bool IsOn(CancelSettings s)
		{
			if (s.Enabled)
			{
				return s.SwapButtons;
			}
			return false;
		}

		public static bool IsSword(string? secondaryAnimation, string? primaryAnimation, int primaryChainLevels)
		{
			return MaxComboPolicy.Eligible(secondaryAnimation, primaryAnimation, primaryChainLevels);
		}

		public static bool ShouldSwap(bool enabled, bool swordEquipped, bool inPlaceMode)
		{
			if (enabled && swordEquipped)
			{
				return !inPlaceMode;
			}
			return false;
		}

		public static (string k, string v)[] LabFields(bool swapped)
		{
			if (!swapped)
			{
				return Array.Empty<(string, string)>();
			}
			return new(string, string)[1] { ("swapped", "1") };
		}
	}
}