using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using Microsoft.CodeAnalysis;
using ValheimMjolnir.Core.Gameplay;
using ValheimMjolnir.Core.Identity;
using ValheimMjolnir.Core.Persistence;
using ValheimMjolnir.Core.State;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.6.2", FrameworkDisplayName = ".NET Framework 4.6.2")]
[assembly: AssemblyCompany("ValheimMjolnir.Core")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("2.6.4.0")]
[assembly: AssemblyInformationalVersion("2.6.4+b4c6ac47ce16619676e8ff87e062a9fca15afbd1")]
[assembly: AssemblyProduct("ValheimMjolnir.Core")]
[assembly: AssemblyTitle("ValheimMjolnir.Core")]
[assembly: AssemblyVersion("2.6.4.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;
		}
	}
}
namespace ValheimMjolnir.Core.State
{
	public enum MjolnirAbilityState
	{
		Idle,
		LightningCharging,
		LightningExecuting,
		Flight,
		GroundSlam,
		Cyclone,
		CrosshairControl,
		ThunderClap,
		StormLine,
		ChainLightning,
		OverheadSlam,
		MultiAngleBarrage,
		Assaulting,
		GroundedLightningRod,
		GodBlastCharging,
		GodBlastDischarging,
		MomentumSlam,
		OrbitingHammer,
		LightningStep,
		Guard
	}
	public readonly struct MjolnirAggregateState : IEquatable<MjolnirAggregateState>
	{
		public MjolnirHammerState Hammer { get; }

		public MjolnirAbilityState Ability { get; }

		public static MjolnirAggregateState Initial => new MjolnirAggregateState(MjolnirHammerState.Stored, MjolnirAbilityState.Idle);

		public MjolnirAggregateState(MjolnirHammerState hammer, MjolnirAbilityState ability)
		{
			Hammer = hammer;
			Ability = ability;
		}

		public bool Equals(MjolnirAggregateState other)
		{
			if (Hammer == other.Hammer)
			{
				return Ability == other.Ability;
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return ((int)Hammer * 397) ^ (int)Ability;
		}

		public override string ToString()
		{
			return $"{Hammer}/{Ability}";
		}

		public static bool operator ==(MjolnirAggregateState left, MjolnirAggregateState right)
		{
			return left.Equals(right);
		}

		public static bool operator !=(MjolnirAggregateState left, MjolnirAggregateState right)
		{
			return !left.Equals(right);
		}
	}
	public static class MjolnirAggregateStateMachine
	{
		public static MjolnirCommandDecision Evaluate(MjolnirAggregateState source, MjolnirCommand command)
		{
			if (!IsValid(source) || !Enum.IsDefined(typeof(MjolnirCommand), command))
			{
				return MjolnirCommandDecision.Reject(source, command);
			}
			MjolnirAggregateState? mjolnirAggregateState;
			switch (command)
			{
			case MjolnirCommand.Equip:
				if (Is(source, MjolnirHammerState.Stored, MjolnirAbilityState.Idle))
				{
					mjolnirAggregateState = State(MjolnirHammerState.Held);
					break;
				}
				goto default;
			case MjolnirCommand.Unequip:
				if (Is(source, MjolnirHammerState.Held, MjolnirAbilityState.Idle))
				{
					mjolnirAggregateState = State(MjolnirHammerState.Stored);
					break;
				}
				goto default;
			case MjolnirCommand.BeginThrowCharge:
				if (Is(source, MjolnirHammerState.Held, MjolnirAbilityState.Idle))
				{
					mjolnirAggregateState = State(MjolnirHammerState.ThrowCharging);
					break;
				}
				goto default;
			case MjolnirCommand.CancelThrowCharge:
				if (Is(source, MjolnirHammerState.ThrowCharging, MjolnirAbilityState.Idle))
				{
					mjolnirAggregateState = State(MjolnirHammerState.Held);
					break;
				}
				goto default;
			case MjolnirCommand.RequestThrowRelease:
				if (Is(source, MjolnirHammerState.ThrowCharging, MjolnirAbilityState.Idle))
				{
					mjolnirAggregateState = State(MjolnirHammerState.ReleasePending);
					break;
				}
				goto default;
			case MjolnirCommand.CancelThrowRelease:
				if (Is(source, MjolnirHammerState.ReleasePending, MjolnirAbilityState.Idle))
				{
					mjolnirAggregateState = State(MjolnirHammerState.Held);
					break;
				}
				goto default;
			case MjolnirCommand.CommitThrow:
				if (Is(source, MjolnirHammerState.ReleasePending, MjolnirAbilityState.Idle))
				{
					mjolnirAggregateState = State(MjolnirHammerState.Outbound);
					break;
				}
				goto default;
			case MjolnirCommand.Embed:
				if (Is(source, MjolnirHammerState.Outbound, MjolnirAbilityState.Idle))
				{
					mjolnirAggregateState = State(MjolnirHammerState.Embedded);
					break;
				}
				goto default;
			case MjolnirCommand.Plant:
			{
				bool flag = source.Ability == MjolnirAbilityState.Idle;
				if (flag)
				{
					MjolnirHammerState hammer = source.Hammer;
					bool flag2 = (((uint)(hammer - 4) <= 2u || hammer == MjolnirHammerState.Levitating) ? true : false);
					flag = flag2;
				}
				if (flag)
				{
					mjolnirAggregateState = State(MjolnirHammerState.Planted);
					break;
				}
				goto default;
			}
			case MjolnirCommand.EmbedInEnemy:
				if (Is(source, MjolnirHammerState.Outbound, MjolnirAbilityState.Idle))
				{
					mjolnirAggregateState = State(MjolnirHammerState.EmbeddedInEnemy);
					break;
				}
				goto default;
			case MjolnirCommand.ReleaseEnemyEmbedToDropped:
				if (Is(source, MjolnirHammerState.EmbeddedInEnemy, MjolnirAbilityState.Idle))
				{
					mjolnirAggregateState = State(MjolnirHammerState.Dropped);
					break;
				}
				goto default;
			case MjolnirCommand.Drop:
			{
				bool flag = source.Ability == MjolnirAbilityState.Idle;
				if (flag)
				{
					MjolnirHammerState hammer = source.Hammer;
					bool flag2 = (uint)hammer <= 1u;
					flag = flag2;
				}
				if (flag)
				{
					mjolnirAggregateState = State(MjolnirHammerState.Dropped);
					break;
				}
				goto default;
			}
			case MjolnirCommand.Pickup:
				if (Is(source, MjolnirHammerState.Dropped, MjolnirAbilityState.Idle))
				{
					mjolnirAggregateState = State(MjolnirHammerState.Stored);
					break;
				}
				goto default;
			case MjolnirCommand.BeginRecall:
			{
				MjolnirAbilityState ability = source.Ability;
				bool flag = ((ability == MjolnirAbilityState.Idle || ability == MjolnirAbilityState.GroundedLightningRod) ? true : false);
				bool flag2 = flag;
				if (flag2)
				{
					bool flag3;
					switch (source.Hammer)
					{
					case MjolnirHammerState.Outbound:
					case MjolnirHammerState.Embedded:
					case MjolnirHammerState.CrosshairControlled:
					case MjolnirHammerState.Levitating:
					case MjolnirHammerState.Planted:
					case MjolnirHammerState.EmbeddedInEnemy:
						flag3 = true;
						break;
					default:
						flag3 = false;
						break;
					}
					flag2 = flag3;
				}
				if (flag2)
				{
					mjolnirAggregateState = State(MjolnirHammerState.Returning);
					break;
				}
				goto default;
			}
			case MjolnirCommand.CancelRecallToOutbound:
				if (Is(source, MjolnirHammerState.Returning, MjolnirAbilityState.Idle))
				{
					mjolnirAggregateState = State(MjolnirHammerState.Outbound);
					break;
				}
				goto default;
			case MjolnirCommand.CancelRecallToEmbedded:
				if (Is(source, MjolnirHammerState.Returning, MjolnirAbilityState.Idle))
				{
					mjolnirAggregateState = State(MjolnirHammerState.Embedded);
					break;
				}
				goto default;
			case MjolnirCommand.BeginCatch:
				if (Is(source, MjolnirHammerState.Returning, MjolnirAbilityState.Idle))
				{
					mjolnirAggregateState = State(MjolnirHammerState.Catching);
					break;
				}
				goto default;
			case MjolnirCommand.CompleteCatch:
				if (Is(source, MjolnirHammerState.Catching, MjolnirAbilityState.Idle))
				{
					mjolnirAggregateState = State(MjolnirHammerState.Held);
					break;
				}
				goto default;
			case MjolnirCommand.BeginOrbit:
				if (Is(source, MjolnirHammerState.Returning, MjolnirAbilityState.Idle))
				{
					mjolnirAggregateState = new MjolnirAggregateState(MjolnirHammerState.Orbiting, MjolnirAbilityState.OrbitingHammer);
					break;
				}
				goto default;
			case MjolnirCommand.EndOrbitToRecall:
				if (Is(source, MjolnirHammerState.Orbiting, MjolnirAbilityState.OrbitingHammer))
				{
					mjolnirAggregateState = State(MjolnirHammerState.Returning);
					break;
				}
				goto default;
			case MjolnirCommand.ReleaseOrbit:
				if (Is(source, MjolnirHammerState.Orbiting, MjolnirAbilityState.OrbitingHammer))
				{
					mjolnirAggregateState = State(MjolnirHammerState.Outbound);
					break;
				}
				goto default;
			case MjolnirCommand.BeginCrosshairControl:
			{
				MjolnirHammerState hammer = source.Hammer;
				bool flag2 = (uint)(hammer - 4) <= 2u;
				bool flag = flag2 && source.Ability == MjolnirAbilityState.Idle;
				if (!flag)
				{
					bool flag3 = source.Hammer == MjolnirHammerState.Levitating;
					if (flag3)
					{
						MjolnirAbilityState ability = source.Ability;
						bool flag4 = (uint)ability <= 2u;
						flag3 = flag4;
					}
					flag = flag3;
				}
				if (flag)
				{
					mjolnirAggregateState = new MjolnirAggregateState(MjolnirHammerState.CrosshairControlled, source.Ability);
					break;
				}
				goto default;
			}
			case MjolnirCommand.UpdateCrosshairTarget:
			{
				bool flag = source.Hammer == MjolnirHammerState.CrosshairControlled;
				if (flag)
				{
					MjolnirAbilityState ability = source.Ability;
					bool flag2 = (uint)ability <= 2u;
					flag = flag2;
				}
				if (flag)
				{
					mjolnirAggregateState = new MjolnirAggregateState(MjolnirHammerState.CrosshairControlled, source.Ability);
					break;
				}
				goto default;
			}
			case MjolnirCommand.CompleteCrosshairControl:
				if (source.Hammer == MjolnirHammerState.CrosshairControlled)
				{
					mjolnirAggregateState = new MjolnirAggregateState(MjolnirHammerState.Levitating, source.Ability);
					break;
				}
				goto default;
			case MjolnirCommand.ReleaseCrosshairControl:
			{
				MjolnirHammerState hammer = source.Hammer;
				if ((uint)(hammer - 9) <= 1u)
				{
					mjolnirAggregateState = new MjolnirAggregateState(MjolnirHammerState.Outbound, source.Ability);
					break;
				}
				goto default;
			}
			case MjolnirCommand.ExhaustCrosshairControl:
				if (source.Hammer == MjolnirHammerState.CrosshairControlled)
				{
					mjolnirAggregateState = new MjolnirAggregateState(MjolnirHammerState.Levitating, source.Ability);
					break;
				}
				goto default;
			case MjolnirCommand.BeginLightningCharge:
			{
				bool flag = source.Ability == MjolnirAbilityState.Idle;
				if (flag)
				{
					bool flag2;
					switch (source.Hammer)
					{
					case MjolnirHammerState.Held:
					case MjolnirHammerState.Embedded:
					case MjolnirHammerState.Dropped:
					case MjolnirHammerState.CrosshairControlled:
					case MjolnirHammerState.Levitating:
					case MjolnirHammerState.EmbeddedInEnemy:
						flag2 = true;
						break;
					default:
						flag2 = false;
						break;
					}
					flag = flag2;
				}
				if (flag)
				{
					mjolnirAggregateState = new MjolnirAggregateState(source.Hammer, MjolnirAbilityState.LightningCharging);
					break;
				}
				goto default;
			}
			case MjolnirCommand.CancelLightningCharge:
				if (source.Ability == MjolnirAbilityState.LightningCharging)
				{
					mjolnirAggregateState = new MjolnirAggregateState(source.Hammer, MjolnirAbilityState.Idle);
					break;
				}
				goto default;
			case MjolnirCommand.CommitLightningCast:
				if (source.Ability == MjolnirAbilityState.LightningCharging)
				{
					mjolnirAggregateState = new MjolnirAggregateState(source.Hammer, MjolnirAbilityState.LightningExecuting);
					break;
				}
				goto default;
			case MjolnirCommand.CancelLightningCast:
				if (source.Ability == MjolnirAbilityState.LightningExecuting)
				{
					mjolnirAggregateState = new MjolnirAggregateState(source.Hammer, MjolnirAbilityState.Idle);
					break;
				}
				goto default;
			case MjolnirCommand.CompleteLightning:
				if (source.Ability == MjolnirAbilityState.LightningCharging)
				{
					mjolnirAggregateState = new MjolnirAggregateState(source.Hammer, MjolnirAbilityState.Idle);
					break;
				}
				if (source.Ability == MjolnirAbilityState.LightningExecuting)
				{
					mjolnirAggregateState = new MjolnirAggregateState(source.Hammer, MjolnirAbilityState.Idle);
					break;
				}
				goto default;
			case MjolnirCommand.BeginFlight:
				if (Is(source, MjolnirHammerState.Held, MjolnirAbilityState.Idle))
				{
					mjolnirAggregateState = new MjolnirAggregateState(MjolnirHammerState.Held, MjolnirAbilityState.Flight);
					break;
				}
				goto default;
			case MjolnirCommand.EndFlight:
				if (Is(source, MjolnirHammerState.Held, MjolnirAbilityState.Flight))
				{
					mjolnirAggregateState = State(MjolnirHammerState.Held);
					break;
				}
				goto default;
			case MjolnirCommand.BeginGroundSlam:
				if (Is(source, MjolnirHammerState.Held, MjolnirAbilityState.Flight))
				{
					mjolnirAggregateState = new MjolnirAggregateState(MjolnirHammerState.Held, MjolnirAbilityState.GroundSlam);
					break;
				}
				goto default;
			case MjolnirCommand.CompleteGroundSlam:
				if (Is(source, MjolnirHammerState.Held, MjolnirAbilityState.GroundSlam))
				{
					mjolnirAggregateState = State(MjolnirHammerState.Held);
					break;
				}
				goto default;
			case MjolnirCommand.BeginMomentumSlam:
			{
				bool flag = source.Hammer == MjolnirHammerState.Held;
				if (flag)
				{
					MjolnirAbilityState ability = source.Ability;
					bool flag2 = ((ability == MjolnirAbilityState.Idle || ability == MjolnirAbilityState.Flight) ? true : false);
					flag = flag2;
				}
				if (flag)
				{
					mjolnirAggregateState = new MjolnirAggregateState(MjolnirHammerState.Held, MjolnirAbilityState.MomentumSlam);
					break;
				}
				goto default;
			}
			case MjolnirCommand.CompleteMomentumSlam:
				if (Is(source, MjolnirHammerState.Held, MjolnirAbilityState.MomentumSlam))
				{
					mjolnirAggregateState = State(MjolnirHammerState.Held);
					break;
				}
				goto default;
			case MjolnirCommand.BeginLightningStep:
			{
				bool flag = source.Hammer == MjolnirHammerState.Held;
				if (flag)
				{
					MjolnirAbilityState ability = source.Ability;
					bool flag2 = ((ability == MjolnirAbilityState.Idle || ability == MjolnirAbilityState.Flight) ? true : false);
					flag = flag2;
				}
				if (flag)
				{
					mjolnirAggregateState = new MjolnirAggregateState(MjolnirHammerState.Held, MjolnirAbilityState.LightningStep);
					break;
				}
				goto default;
			}
			case MjolnirCommand.CompleteLightningStep:
				if (Is(source, MjolnirHammerState.Held, MjolnirAbilityState.LightningStep))
				{
					mjolnirAggregateState = State(MjolnirHammerState.Held);
					break;
				}
				goto default;
			case MjolnirCommand.BeginGuard:
				if (Is(source, MjolnirHammerState.Held, MjolnirAbilityState.Idle))
				{
					mjolnirAggregateState = new MjolnirAggregateState(MjolnirHammerState.Held, MjolnirAbilityState.Guard);
					break;
				}
				goto default;
			case MjolnirCommand.CompleteGuard:
				if (Is(source, MjolnirHammerState.Held, MjolnirAbilityState.Guard))
				{
					mjolnirAggregateState = State(MjolnirHammerState.Held);
					break;
				}
				goto default;
			case MjolnirCommand.MarkUnavailable:
				if (source.Hammer != MjolnirHammerState.Unavailable)
				{
					mjolnirAggregateState = State(MjolnirHammerState.Unavailable);
					break;
				}
				goto default;
			case MjolnirCommand.RecoverStored:
				if (Is(source, MjolnirHammerState.Unavailable, MjolnirAbilityState.Idle))
				{
					mjolnirAggregateState = State(MjolnirHammerState.Stored);
					break;
				}
				goto default;
			case MjolnirCommand.RecoverDropped:
				if (Is(source, MjolnirHammerState.Unavailable, MjolnirAbilityState.Idle))
				{
					mjolnirAggregateState = State(MjolnirHammerState.Dropped);
					break;
				}
				goto default;
			default:
				mjolnirAggregateState = null;
				break;
			}
			MjolnirAggregateState? mjolnirAggregateState2 = mjolnirAggregateState;
			if (!mjolnirAggregateState2.HasValue || !IsValid(mjolnirAggregateState2.Value))
			{
				return MjolnirCommandDecision.Reject(source, command);
			}
			return MjolnirCommandDecision.Accept(source, mjolnirAggregateState2.Value, command);
		}

		public static bool IsValid(MjolnirAggregateState state)
		{
			if (!Enum.IsDefined(typeof(MjolnirHammerState), state.Hammer) || !Enum.IsDefined(typeof(MjolnirAbilityState), state.Ability))
			{
				return false;
			}
			switch (state.Ability)
			{
			case MjolnirAbilityState.Idle:
				return true;
			case MjolnirAbilityState.LightningCharging:
			{
				bool result;
				switch (state.Hammer)
				{
				case MjolnirHammerState.Held:
				case MjolnirHammerState.Outbound:
				case MjolnirHammerState.Embedded:
				case MjolnirHammerState.Dropped:
				case MjolnirHammerState.CrosshairControlled:
				case MjolnirHammerState.Levitating:
				case MjolnirHammerState.EmbeddedInEnemy:
					result = true;
					break;
				default:
					result = false;
					break;
				}
				return result;
			}
			case MjolnirAbilityState.LightningExecuting:
			{
				bool result;
				switch (state.Hammer)
				{
				case MjolnirHammerState.Held:
				case MjolnirHammerState.Outbound:
				case MjolnirHammerState.Embedded:
				case MjolnirHammerState.Dropped:
				case MjolnirHammerState.CrosshairControlled:
				case MjolnirHammerState.Levitating:
				case MjolnirHammerState.EmbeddedInEnemy:
					result = true;
					break;
				default:
					result = false;
					break;
				}
				return result;
			}
			case MjolnirAbilityState.Flight:
			case MjolnirAbilityState.GroundSlam:
			case MjolnirAbilityState.MomentumSlam:
				return state.Hammer == MjolnirHammerState.Held;
			case MjolnirAbilityState.LightningStep:
				return state.Hammer == MjolnirHammerState.Held;
			case MjolnirAbilityState.Guard:
				return state.Hammer == MjolnirHammerState.Held;
			case MjolnirAbilityState.ThunderClap:
			case MjolnirAbilityState.StormLine:
			case MjolnirAbilityState.OverheadSlam:
				return state.Hammer == MjolnirHammerState.Held;
			case MjolnirAbilityState.Cyclone:
			case MjolnirAbilityState.CrosshairControl:
			case MjolnirAbilityState.ChainLightning:
			case MjolnirAbilityState.MultiAngleBarrage:
			{
				MjolnirHammerState hammer = state.Hammer;
				return ((uint)(hammer - 4) <= 3u || (uint)(hammer - 9) <= 1u) ? true : false;
			}
			case MjolnirAbilityState.Assaulting:
				return state.Hammer == MjolnirHammerState.CrosshairControlled;
			case MjolnirAbilityState.GroundedLightningRod:
				return state.Hammer == MjolnirHammerState.Planted;
			case MjolnirAbilityState.OrbitingHammer:
				return state.Hammer == MjolnirHammerState.Orbiting;
			case MjolnirAbilityState.GodBlastCharging:
			case MjolnirAbilityState.GodBlastDischarging:
				return state.Hammer == MjolnirHammerState.Held;
			default:
				return false;
			}
		}

		private static bool Is(MjolnirAggregateState state, MjolnirHammerState hammer, MjolnirAbilityState ability)
		{
			if (state.Hammer == hammer)
			{
				return state.Ability == ability;
			}
			return false;
		}

		private static MjolnirAggregateState State(MjolnirHammerState hammer)
		{
			return new MjolnirAggregateState(hammer, MjolnirAbilityState.Idle);
		}
	}
	public enum MjolnirCommand
	{
		Equip,
		Unequip,
		BeginThrowCharge,
		CancelThrowCharge,
		RequestThrowRelease,
		CancelThrowRelease,
		CommitThrow,
		Embed,
		Drop,
		Pickup,
		BeginRecall,
		CancelRecallToOutbound,
		CancelRecallToEmbedded,
		BeginCatch,
		CompleteCatch,
		BeginCrosshairControl,
		UpdateCrosshairTarget,
		CompleteCrosshairControl,
		ExhaustCrosshairControl,
		BeginLightningCharge,
		CancelLightningCharge,
		CommitLightningCast,
		CancelLightningCast,
		CompleteLightning,
		BeginFlight,
		EndFlight,
		BeginGroundSlam,
		CompleteGroundSlam,
		BeginMomentumSlam,
		CompleteMomentumSlam,
		MarkUnavailable,
		RecoverStored,
		RecoverDropped,
		ReleaseCrosshairControl,
		Plant,
		BeginOrbit,
		EndOrbitToRecall,
		ReleaseOrbit,
		BeginLightningStep,
		CompleteLightningStep,
		BeginGuard,
		CompleteGuard,
		EmbedInEnemy,
		ReleaseEnemyEmbedToDropped
	}
	public sealed class MjolnirCommandDecision
	{
		public bool Accepted { get; }

		public MjolnirAggregateState Source { get; }

		public MjolnirAggregateState Target { get; }

		public MjolnirCommand Command { get; }

		public TransitionFailure Failure { get; }

		private MjolnirCommandDecision(bool accepted, MjolnirAggregateState source, MjolnirAggregateState target, MjolnirCommand command, TransitionFailure failure)
		{
			Accepted = accepted;
			Source = source;
			Target = target;
			Command = command;
			Failure = failure;
		}

		internal static MjolnirCommandDecision Accept(MjolnirAggregateState source, MjolnirAggregateState target, MjolnirCommand command)
		{
			return new MjolnirCommandDecision(accepted: true, source, target, command, TransitionFailure.None);
		}

		internal static MjolnirCommandDecision Reject(MjolnirAggregateState source, MjolnirCommand command)
		{
			return new MjolnirCommandDecision(accepted: false, source, source, command, TransitionFailure.InvalidTransition);
		}
	}
	public enum MjolnirHammerState
	{
		Stored,
		Held,
		ThrowCharging,
		ReleasePending,
		Outbound,
		Embedded,
		Dropped,
		Returning,
		Catching,
		CrosshairControlled,
		Levitating,
		Unavailable,
		Planted,
		Orbiting,
		EmbeddedInEnemy
	}
	public enum MjolnirState
	{
		Stored,
		Equipped,
		Held,
		Charging,
		MeleeAttack,
		ThrownOutbound,
		Embedded,
		Dropped,
		Orbiting,
		Recalling,
		Returning,
		Caught,
		LightningSummoned,
		FlightActive,
		GroundSlam,
		CrosshairControlled,
		Levitating,
		Unavailable,
		Planted,
		EmbeddedInEnemy
	}
	public static class MjolnirStateMachine
	{
		private static readonly IReadOnlyDictionary<MjolnirState, MjolnirState[]> Transitions = new Dictionary<MjolnirState, MjolnirState[]>
		{
			[MjolnirState.Stored] = States(MjolnirState.Equipped, MjolnirState.LightningSummoned, MjolnirState.Unavailable),
			[MjolnirState.Equipped] = States(MjolnirState.Held, MjolnirState.Stored, MjolnirState.Unavailable),
			[MjolnirState.Held] = States(MjolnirState.Charging, MjolnirState.MeleeAttack, MjolnirState.ThrownOutbound, MjolnirState.FlightActive, MjolnirState.Equipped, MjolnirState.Stored, MjolnirState.Unavailable),
			[MjolnirState.Charging] = States(MjolnirState.Held, MjolnirState.MeleeAttack, MjolnirState.ThrownOutbound, MjolnirState.Unavailable),
			[MjolnirState.MeleeAttack] = States(MjolnirState.Held, MjolnirState.Unavailable),
			[MjolnirState.ThrownOutbound] = States(MjolnirState.Embedded, MjolnirState.EmbeddedInEnemy, MjolnirState.Planted, MjolnirState.Dropped, MjolnirState.Orbiting, MjolnirState.Recalling, MjolnirState.Returning, MjolnirState.CrosshairControlled, MjolnirState.Unavailable),
			[MjolnirState.Embedded] = States(MjolnirState.Planted, MjolnirState.Recalling, MjolnirState.Returning, MjolnirState.Dropped, MjolnirState.LightningSummoned, MjolnirState.CrosshairControlled, MjolnirState.Unavailable),
			[MjolnirState.EmbeddedInEnemy] = States(MjolnirState.Recalling, MjolnirState.Returning, MjolnirState.Dropped, MjolnirState.Unavailable),
			[MjolnirState.Dropped] = States(MjolnirState.Stored, MjolnirState.Equipped, MjolnirState.Planted, MjolnirState.Recalling, MjolnirState.Returning, MjolnirState.LightningSummoned, MjolnirState.CrosshairControlled, MjolnirState.Unavailable),
			[MjolnirState.Orbiting] = States(MjolnirState.ThrownOutbound, MjolnirState.Recalling, MjolnirState.Returning, MjolnirState.Dropped, MjolnirState.Unavailable),
			[MjolnirState.Planted] = States(MjolnirState.Recalling, MjolnirState.Returning, MjolnirState.Dropped, MjolnirState.Unavailable),
			[MjolnirState.Recalling] = States(MjolnirState.Returning, MjolnirState.Unavailable),
			[MjolnirState.Returning] = States(MjolnirState.Caught, MjolnirState.Orbiting, MjolnirState.ThrownOutbound, MjolnirState.Embedded, MjolnirState.Dropped, MjolnirState.Unavailable),
			[MjolnirState.Caught] = States(MjolnirState.Held, MjolnirState.Unavailable),
			[MjolnirState.LightningSummoned] = States(MjolnirState.Returning, MjolnirState.Caught, MjolnirState.Unavailable),
			[MjolnirState.FlightActive] = States(MjolnirState.GroundSlam, MjolnirState.Held, MjolnirState.Unavailable),
			[MjolnirState.GroundSlam] = States(MjolnirState.Held, MjolnirState.Unavailable),
			[MjolnirState.CrosshairControlled] = States(MjolnirState.Levitating, MjolnirState.ThrownOutbound, MjolnirState.Recalling, MjolnirState.Dropped, MjolnirState.Unavailable),
			[MjolnirState.Levitating] = States(MjolnirState.Planted, MjolnirState.CrosshairControlled, MjolnirState.ThrownOutbound, MjolnirState.Recalling, MjolnirState.Returning, MjolnirState.Dropped, MjolnirState.Unavailable),
			[MjolnirState.Unavailable] = States(MjolnirState.Stored, MjolnirState.Dropped, MjolnirState.Equipped)
		};

		public static bool CanTransition(MjolnirState source, MjolnirState target)
		{
			if (!Transitions.TryGetValue(source, out MjolnirState[] value))
			{
				return false;
			}
			return Array.IndexOf(value, target) >= 0;
		}

		public static IReadOnlyList<MjolnirState> AllowedFrom(MjolnirState source)
		{
			if (!Transitions.TryGetValue(source, out MjolnirState[] value))
			{
				return Array.Empty<MjolnirState>();
			}
			return value;
		}

		public static TransitionDecision Evaluate(MjolnirState source, MjolnirState target)
		{
			if (!CanTransition(source, target))
			{
				return TransitionDecision.Reject(source, target);
			}
			return TransitionDecision.Accept(source, target);
		}

		private static MjolnirState[] States(params MjolnirState[] states)
		{
			return states;
		}
	}
	public sealed class TransitionDecision
	{
		public bool Accepted { get; }

		public MjolnirState Source { get; }

		public MjolnirState Target { get; }

		public TransitionFailure Failure { get; }

		private TransitionDecision(bool accepted, MjolnirState source, MjolnirState target, TransitionFailure failure)
		{
			Accepted = accepted;
			Source = source;
			Target = target;
			Failure = failure;
		}

		public static TransitionDecision Accept(MjolnirState source, MjolnirState target)
		{
			return new TransitionDecision(accepted: true, source, target, TransitionFailure.None);
		}

		public static TransitionDecision Reject(MjolnirState source, MjolnirState target)
		{
			return new TransitionDecision(accepted: false, source, target, TransitionFailure.InvalidTransition);
		}
	}
	public enum TransitionFailure
	{
		None,
		UnknownHammer,
		InvalidHammerId,
		InvalidTransactionId,
		InvalidTransition,
		EpochMismatch,
		SequenceMismatch,
		RevisionMismatch,
		DuplicateHammer,
		WorldMismatch,
		WorldAlreadyIssued,
		NoIssuance,
		TransactionConflict,
		InvalidSnapshot,
		UnsupportedSchema
	}
}
namespace ValheimMjolnir.Core.Persistence
{
	public sealed class HammerLedger
	{
		private enum LedgerCommandKind
		{
			Issue,
			Transition,
			AdvanceEpochForRecovery
		}

		private readonly struct LedgerCommandFingerprint : IEquatable<LedgerCommandFingerprint>
		{
			private LedgerCommandKind Kind { get; }

			private HammerIdentity Identity { get; }

			private long ExpectedStateSequence { get; }

			private long ExpectedRevision { get; }

			private MjolnirCommand? Command { get; }

			internal LedgerCommandFingerprint(LedgerCommandKind kind, HammerIdentity identity, long expectedStateSequence, long expectedRevision, MjolnirCommand? command)
			{
				Kind = kind;
				Identity = identity;
				ExpectedStateSequence = expectedStateSequence;
				ExpectedRevision = expectedRevision;
				Command = command;
			}

			public bool Equals(LedgerCommandFingerprint other)
			{
				if (Kind == other.Kind && Identity.Equals(other.Identity) && ExpectedStateSequence == other.ExpectedStateSequence && ExpectedRevision == other.ExpectedRevision)
				{
					return Command == other.Command;
				}
				return false;
			}

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

			public override int GetHashCode()
			{
				return ((((((((int)Kind * 397) ^ Identity.GetHashCode()) * 397) ^ ExpectedStateSequence.GetHashCode()) * 397) ^ ExpectedRevision.GetHashCode()) * 397) ^ (Command?.GetHashCode() ?? 0);
			}
		}

		private sealed class TransactionCacheEntry
		{
			internal LedgerCommandFingerprint Fingerprint { get; }

			internal LedgerCommandResult Result { get; }

			internal TransactionCacheEntry(LedgerCommandFingerprint fingerprint, LedgerCommandResult result)
			{
				Fingerprint = fingerprint;
				Result = result;
			}
		}

		private sealed class Record
		{
			internal HammerIdentity Identity { get; set; }

			internal Guid HammerId => Identity.HammerId;

			internal MjolnirAggregateState RuntimeState { get; set; }

			internal long StateSequence { get; set; }

			internal long Revision { get; set; }

			internal Record(HammerIdentity identity, MjolnirAggregateState runtimeState, long stateSequence, long revision)
			{
				Identity = identity;
				RuntimeState = runtimeState;
				StateSequence = stateSequence;
				Revision = revision;
			}

			internal LedgerSnapshot ToSnapshot()
			{
				return new LedgerSnapshot(Identity, RuntimeState, HammerRepresentationPolicy.For(RuntimeState.Hammer), StateSequence, Revision);
			}
		}

		private sealed class TransactionResultCache
		{
			private readonly int capacity;

			private readonly Dictionary<Guid, TransactionCacheEntry> results = new Dictionary<Guid, TransactionCacheEntry>();

			private readonly Queue<Guid> insertionOrder = new Queue<Guid>();

			internal TransactionResultCache(int capacity)
			{
				if (capacity < 1)
				{
					throw new ArgumentOutOfRangeException("capacity");
				}
				this.capacity = capacity;
			}

			internal bool TryGet(Guid transactionId, out TransactionCacheEntry? result)
			{
				return results.TryGetValue(transactionId, out result);
			}

			internal void Add(Guid transactionId, TransactionCacheEntry result)
			{
				if (!results.ContainsKey(transactionId))
				{
					while (results.Count >= capacity)
					{
						Guid key = insertionOrder.Dequeue();
						results.Remove(key);
					}
					results.Add(transactionId, result);
					insertionOrder.Enqueue(transactionId);
				}
			}
		}

		private readonly object gate = new object();

		private readonly TransactionResultCache transactionResults;

		private Record? record;

		public long WorldUid { get; }

		public bool HasIssuance
		{
			get
			{
				lock (gate)
				{
					return record != null;
				}
			}
		}

		public HammerLedger(long worldUid, int transactionCacheCapacity = 512)
		{
			if (worldUid == 0L)
			{
				throw new ArgumentOutOfRangeException("worldUid", "A ledger must be bound to a nonzero world UID.");
			}
			WorldUid = worldUid;
			transactionResults = new TransactionResultCache(transactionCacheCapacity);
		}

		public LedgerCommandResult Issue(HammerIdentity identity, Guid transactionId)
		{
			lock (gate)
			{
				LedgerCommandFingerprint fingerprint = new LedgerCommandFingerprint(LedgerCommandKind.Issue, identity, 0L, 0L, null);
				if (TryReplay(transactionId, fingerprint, out LedgerCommandResult result))
				{
					return result;
				}
				if (transactionId == Guid.Empty)
				{
					return LedgerCommandResult.Reject(TransitionFailure.InvalidTransactionId, null);
				}
				if (identity.LedgerWorldUid != WorldUid)
				{
					return Cache(transactionId, LedgerCommandResult.Reject(TransitionFailure.WorldMismatch, record?.ToSnapshot()), fingerprint);
				}
				if (record != null)
				{
					TransitionFailure failure = ((record.HammerId == identity.HammerId) ? TransitionFailure.DuplicateHammer : TransitionFailure.WorldAlreadyIssued);
					return Cache(transactionId, LedgerCommandResult.Reject(failure, record.ToSnapshot()), fingerprint);
				}
				record = new Record(identity, MjolnirAggregateState.Initial, 0L, 1L);
				return Cache(transactionId, LedgerCommandResult.Accept(record.ToSnapshot()), fingerprint);
			}
		}

		public LedgerCommandResult Transition(HammerIdentity identity, long expectedStateSequence, long expectedRevision, MjolnirCommand command, Guid transactionId)
		{
			checked
			{
				lock (gate)
				{
					LedgerCommandFingerprint fingerprint = new LedgerCommandFingerprint(LedgerCommandKind.Transition, identity, expectedStateSequence, expectedRevision, command);
					if (TryReplay(transactionId, fingerprint, out LedgerCommandResult result))
					{
						return result;
					}
					if (transactionId == Guid.Empty)
					{
						return LedgerCommandResult.Reject(TransitionFailure.InvalidTransactionId, null);
					}
					if (identity.LedgerWorldUid != WorldUid)
					{
						return Cache(transactionId, LedgerCommandResult.Reject(TransitionFailure.WorldMismatch, record?.ToSnapshot()), fingerprint);
					}
					if (record == null)
					{
						return Cache(transactionId, LedgerCommandResult.Reject(TransitionFailure.NoIssuance, null), fingerprint);
					}
					if (record.Identity.HammerId != identity.HammerId)
					{
						return Cache(transactionId, LedgerCommandResult.Reject(TransitionFailure.UnknownHammer, record.ToSnapshot()), fingerprint);
					}
					if (record.Identity.Epoch != identity.Epoch)
					{
						return Cache(transactionId, LedgerCommandResult.Reject(TransitionFailure.EpochMismatch, record.ToSnapshot()), fingerprint);
					}
					if (record.StateSequence != expectedStateSequence)
					{
						return Cache(transactionId, LedgerCommandResult.Reject(TransitionFailure.SequenceMismatch, record.ToSnapshot()), fingerprint);
					}
					if (record.Revision != expectedRevision)
					{
						return Cache(transactionId, LedgerCommandResult.Reject(TransitionFailure.RevisionMismatch, record.ToSnapshot()), fingerprint);
					}
					MjolnirCommandDecision mjolnirCommandDecision = MjolnirAggregateStateMachine.Evaluate(record.RuntimeState, command);
					if (!mjolnirCommandDecision.Accepted)
					{
						return Cache(transactionId, LedgerCommandResult.Reject(mjolnirCommandDecision.Failure, record.ToSnapshot()), fingerprint);
					}
					record.RuntimeState = mjolnirCommandDecision.Target;
					record.StateSequence += 1;
					record.Revision += 1;
					return Cache(transactionId, LedgerCommandResult.Accept(record.ToSnapshot()), fingerprint);
				}
			}
		}

		public static LedgerRestoreResult TryRestore(LedgerSnapshot? snapshot, int transactionCacheCapacity = 512)
		{
			if (snapshot == null)
			{
				return LedgerRestoreResult.Reject(TransitionFailure.InvalidSnapshot);
			}
			if (snapshot.Schema != 1)
			{
				return LedgerRestoreResult.Reject(TransitionFailure.UnsupportedSchema);
			}
			HammerIdentity identity = snapshot.Identity;
			if (identity.HammerId == Guid.Empty || identity.Epoch < 0 || identity.LedgerWorldUid == 0L || snapshot.StateSequence < 0 || snapshot.Revision <= 0 || !MjolnirAggregateStateMachine.IsValid(snapshot.RuntimeState))
			{
				return LedgerRestoreResult.Reject(TransitionFailure.InvalidSnapshot);
			}
			HammerRepresentation hammerRepresentation;
			try
			{
				hammerRepresentation = HammerRepresentationPolicy.For(snapshot.RuntimeState.Hammer);
			}
			catch (ArgumentOutOfRangeException)
			{
				return LedgerRestoreResult.Reject(TransitionFailure.InvalidSnapshot);
			}
			if (snapshot.Representation != hammerRepresentation)
			{
				return LedgerRestoreResult.Reject(TransitionFailure.InvalidSnapshot);
			}
			return LedgerRestoreResult.Accept(new HammerLedger(identity.LedgerWorldUid, transactionCacheCapacity)
			{
				record = new Record(identity, snapshot.RuntimeState, snapshot.StateSequence, snapshot.Revision)
			});
		}

		public LedgerCommandResult AdvanceEpochForRecovery(HammerIdentity expectedIdentity, long expectedRevision, Guid transactionId)
		{
			lock (gate)
			{
				LedgerCommandFingerprint fingerprint = new LedgerCommandFingerprint(LedgerCommandKind.AdvanceEpochForRecovery, expectedIdentity, 0L, expectedRevision, null);
				if (TryReplay(transactionId, fingerprint, out LedgerCommandResult result))
				{
					return result;
				}
				if (transactionId == Guid.Empty)
				{
					return LedgerCommandResult.Reject(TransitionFailure.InvalidTransactionId, null);
				}
				if (expectedIdentity.LedgerWorldUid != WorldUid)
				{
					return Cache(transactionId, LedgerCommandResult.Reject(TransitionFailure.WorldMismatch, record?.ToSnapshot()), fingerprint);
				}
				if (record == null)
				{
					return Cache(transactionId, LedgerCommandResult.Reject(TransitionFailure.NoIssuance, null), fingerprint);
				}
				if (record.Identity.HammerId != expectedIdentity.HammerId)
				{
					return Cache(transactionId, LedgerCommandResult.Reject(TransitionFailure.UnknownHammer, record.ToSnapshot()), fingerprint);
				}
				if (record.Identity.Epoch != expectedIdentity.Epoch)
				{
					return Cache(transactionId, LedgerCommandResult.Reject(TransitionFailure.EpochMismatch, record.ToSnapshot()), fingerprint);
				}
				if (record.Revision != expectedRevision)
				{
					return Cache(transactionId, LedgerCommandResult.Reject(TransitionFailure.RevisionMismatch, record.ToSnapshot()), fingerprint);
				}
				if (record.RuntimeState.Hammer != MjolnirHammerState.Unavailable)
				{
					return Cache(transactionId, LedgerCommandResult.Reject(TransitionFailure.InvalidTransition, record.ToSnapshot()), fingerprint);
				}
				record.Identity = record.Identity.NextEpoch();
				record.RuntimeState = MjolnirAggregateState.Initial;
				record.StateSequence = 0L;
				record.Revision = checked(record.Revision + 1);
				return Cache(transactionId, LedgerCommandResult.Accept(record.ToSnapshot()), fingerprint);
			}
		}

		public bool TryGet(out LedgerSnapshot? snapshot)
		{
			lock (gate)
			{
				if (record != null)
				{
					snapshot = record.ToSnapshot();
					return true;
				}
				snapshot = null;
				return false;
			}
		}

		private bool TryReplay(Guid transactionId, LedgerCommandFingerprint fingerprint, out LedgerCommandResult? result)
		{
			if (transactionId != Guid.Empty && transactionResults.TryGet(transactionId, out TransactionCacheEntry result2))
			{
				result = (result2.Fingerprint.Equals(fingerprint) ? result2.Result.AsReplay() : LedgerCommandResult.Reject(TransitionFailure.TransactionConflict, record?.ToSnapshot()));
				return true;
			}
			result = null;
			return false;
		}

		private LedgerCommandResult Cache(Guid transactionId, LedgerCommandResult result, LedgerCommandFingerprint fingerprint)
		{
			transactionResults.Add(transactionId, new TransactionCacheEntry(fingerprint, result));
			return result;
		}
	}
	public enum HammerRepresentation
	{
		InventoryToken = 0,
		WorldItemDrop = 1,
		InventoryTokenAndLocalActor = 2,
		Quarantined = 3,
		[Obsolete("Use WorldItemDrop.")]
		WorldActor = 1,
		[Obsolete("Use InventoryTokenAndLocalActor.")]
		InventoryTokenAndWorldActor = 2
	}
	public static class HammerRepresentationPolicy
	{
		public static HammerRepresentation For(MjolnirHammerState state)
		{
			switch (state)
			{
			case MjolnirHammerState.Stored:
			case MjolnirHammerState.Held:
			case MjolnirHammerState.ThrowCharging:
			case MjolnirHammerState.ReleasePending:
				return HammerRepresentation.InventoryToken;
			case MjolnirHammerState.Outbound:
			case MjolnirHammerState.Embedded:
			case MjolnirHammerState.Returning:
			case MjolnirHammerState.Catching:
			case MjolnirHammerState.CrosshairControlled:
			case MjolnirHammerState.Levitating:
			case MjolnirHammerState.Planted:
			case MjolnirHammerState.Orbiting:
			case MjolnirHammerState.EmbeddedInEnemy:
				return HammerRepresentation.InventoryTokenAndLocalActor;
			case MjolnirHammerState.Dropped:
				return HammerRepresentation.WorldItemDrop;
			case MjolnirHammerState.Unavailable:
				return HammerRepresentation.Quarantined;
			default:
				throw new ArgumentOutOfRangeException("state", state, "Unknown hammer state.");
			}
		}
	}
	public sealed class LedgerCommandResult
	{
		public bool Accepted { get; }

		public bool IsReplay { get; }

		public TransitionFailure Failure { get; }

		public LedgerSnapshot? Snapshot { get; }

		private LedgerCommandResult(bool accepted, bool replay, TransitionFailure failure, LedgerSnapshot? snapshot)
		{
			Accepted = accepted;
			IsReplay = replay;
			Failure = failure;
			Snapshot = snapshot;
		}

		internal static LedgerCommandResult Accept(LedgerSnapshot snapshot, bool replay = false)
		{
			return new LedgerCommandResult(accepted: true, replay, TransitionFailure.None, snapshot);
		}

		internal static LedgerCommandResult Reject(TransitionFailure failure, LedgerSnapshot? snapshot, bool replay = false)
		{
			return new LedgerCommandResult(accepted: false, replay, failure, snapshot);
		}

		internal LedgerCommandResult AsReplay()
		{
			if (!Accepted)
			{
				return Reject(Failure, Snapshot, replay: true);
			}
			return Accept(Snapshot, replay: true);
		}
	}
	public sealed class LedgerRestoreResult
	{
		public bool Accepted { get; }

		public TransitionFailure Failure { get; }

		public HammerLedger? Ledger { get; }

		private LedgerRestoreResult(bool accepted, TransitionFailure failure, HammerLedger? ledger)
		{
			Accepted = accepted;
			Failure = failure;
			Ledger = ledger;
		}

		internal static LedgerRestoreResult Accept(HammerLedger ledger)
		{
			return new LedgerRestoreResult(accepted: true, TransitionFailure.None, ledger);
		}

		internal static LedgerRestoreResult Reject(TransitionFailure failure)
		{
			return new LedgerRestoreResult(accepted: false, failure, null);
		}
	}
	public sealed class LedgerSnapshot
	{
		public const int CurrentSchema = 1;

		public int Schema { get; }

		public HammerIdentity Identity { get; }

		public MjolnirAggregateState RuntimeState { get; }

		public HammerRepresentation Representation { get; }

		public long StateSequence { get; }

		public long Revision { get; }

		public LedgerSnapshot(HammerIdentity identity, MjolnirAggregateState runtimeState, HammerRepresentation representation, long stateSequence, long revision, int schema = 1)
		{
			Schema = schema;
			Identity = identity;
			RuntimeState = runtimeState;
			Representation = representation;
			StateSequence = stateSequence;
			Revision = revision;
		}
	}
}
namespace ValheimMjolnir.Core.Net
{
	public enum MjolnirAbilityCode : byte
	{
		None,
		Throw,
		Lightning,
		Flight,
		GroundSlam,
		CrosshairControl,
		Summon,
		ThunderClap,
		StormLine,
		Cyclone,
		ChainLightning,
		LightningPillar,
		AssistedLeap,
		FlightCharge,
		Heavenfall,
		GodOfThunder,
		OverheadSlam,
		SummonStorm,
		MultiAngleBarrage,
		Assault,
		LightningStep,
		Guard,
		ThunderGodOrbit,
		CloneStorm
	}
	public static class MjolnirAbilityCodes
	{
		public static MjolnirAbilityCode FromId(string? abilityId)
		{
			return abilityId switch
			{
				"mjolnir.throw" => MjolnirAbilityCode.Throw, 
				"mjolnir.lightning" => MjolnirAbilityCode.Lightning, 
				"mjolnir.flight" => MjolnirAbilityCode.Flight, 
				"mjolnir.groundslam" => MjolnirAbilityCode.GroundSlam, 
				"mjolnir.crosshaircontrol" => MjolnirAbilityCode.CrosshairControl, 
				"mjolnir.summon" => MjolnirAbilityCode.Summon, 
				"mjolnir.thunderclap" => MjolnirAbilityCode.ThunderClap, 
				"mjolnir.stormline" => MjolnirAbilityCode.StormLine, 
				"mjolnir.cyclone" => MjolnirAbilityCode.Cyclone, 
				"mjolnir.chainlightning" => MjolnirAbilityCode.ChainLightning, 
				"mjolnir.lightningpillar" => MjolnirAbilityCode.LightningPillar, 
				"mjolnir.assistedleap" => MjolnirAbilityCode.AssistedLeap, 
				"mjolnir.flightcharge" => MjolnirAbilityCode.FlightCharge, 
				"mjolnir.heavenfall" => MjolnirAbilityCode.Heavenfall, 
				"mjolnir.godofthunder" => MjolnirAbilityCode.GodOfThunder, 
				"mjolnir.overheadslam" => MjolnirAbilityCode.OverheadSlam, 
				"mjolnir.summonstorm" => MjolnirAbilityCode.SummonStorm, 
				"mjolnir.multianglebarrage" => MjolnirAbilityCode.MultiAngleBarrage, 
				"mjolnir.assault" => MjolnirAbilityCode.Assault, 
				"mjolnir.lightningstep" => MjolnirAbilityCode.LightningStep, 
				"mjolnir.guard" => MjolnirAbilityCode.Guard, 
				"mjolnir.thundergodorbit" => MjolnirAbilityCode.ThunderGodOrbit, 
				"mjolnir.clonestorm" => MjolnirAbilityCode.CloneStorm, 
				_ => MjolnirAbilityCode.None, 
			};
		}

		public static string? ToId(MjolnirAbilityCode code)
		{
			return code switch
			{
				MjolnirAbilityCode.Throw => "mjolnir.throw", 
				MjolnirAbilityCode.Lightning => "mjolnir.lightning", 
				MjolnirAbilityCode.Flight => "mjolnir.flight", 
				MjolnirAbilityCode.GroundSlam => "mjolnir.groundslam", 
				MjolnirAbilityCode.CrosshairControl => "mjolnir.crosshaircontrol", 
				MjolnirAbilityCode.Summon => "mjolnir.summon", 
				MjolnirAbilityCode.ThunderClap => "mjolnir.thunderclap", 
				MjolnirAbilityCode.StormLine => "mjolnir.stormline", 
				MjolnirAbilityCode.Cyclone => "mjolnir.cyclone", 
				MjolnirAbilityCode.ChainLightning => "mjolnir.chainlightning", 
				MjolnirAbilityCode.LightningPillar => "mjolnir.lightningpillar", 
				MjolnirAbilityCode.AssistedLeap => "mjolnir.assistedleap", 
				MjolnirAbilityCode.FlightCharge => "mjolnir.flightcharge", 
				MjolnirAbilityCode.Heavenfall => "mjolnir.heavenfall", 
				MjolnirAbilityCode.GodOfThunder => "mjolnir.godofthunder", 
				MjolnirAbilityCode.OverheadSlam => "mjolnir.overheadslam", 
				MjolnirAbilityCode.SummonStorm => "mjolnir.summonstorm", 
				MjolnirAbilityCode.MultiAngleBarrage => "mjolnir.multianglebarrage", 
				MjolnirAbilityCode.Assault => "mjolnir.assault", 
				MjolnirAbilityCode.LightningStep => "mjolnir.lightningstep", 
				MjolnirAbilityCode.Guard => "mjolnir.guard", 
				MjolnirAbilityCode.ThunderGodOrbit => "mjolnir.thundergodorbit", 
				MjolnirAbilityCode.CloneStorm => "mjolnir.clonestorm", 
				_ => null, 
			};
		}

		public static bool IsKnown(MjolnirAbilityCode code)
		{
			return ToId(code) != null;
		}
	}
	public static class MjolnirNetAdmissionPolicy
	{
		public static NetAdmissionResult Evaluate(in MjolnirNetMessage message, in NetPeerContext context, bool ownsLocally)
		{
			if (!context.IsNetworked)
			{
				return NetAdmissionResult.Reject(NetRejectionReason.NotNetworked);
			}
			if (message.Kind == MjolnirNetMessageKind.None)
			{
				return NetAdmissionResult.Reject(NetRejectionReason.UnknownKind);
			}
			bool num = MjolnirNetProtocol.IsSessionScoped(message.Kind);
			bool flag = message.Hammer.HammerId == MjolnirNetProtocol.SessionHammerId;
			if (num != flag)
			{
				return NetAdmissionResult.Reject(NetRejectionReason.ScopeMismatch);
			}
			if (message.Hammer.LedgerWorldUid != context.WorldUid)
			{
				return NetAdmissionResult.Reject(NetRejectionReason.WrongWorld);
			}
			if (message.SenderPeerId == context.LocalPeerId)
			{
				return NetAdmissionResult.Reject(NetRejectionReason.SelfEcho);
			}
			if (MjolnirNetProtocol.IsDiscrete(message.Kind) && message.ActivationId == 0L)
			{
				return NetAdmissionResult.Reject(NetRejectionReason.MissingActivationId);
			}
			if (message.Kind == MjolnirNetMessageKind.AbilityTriggered && !MjolnirAbilityCodes.IsKnown(message.Ability))
			{
				return NetAdmissionResult.Reject(NetRejectionReason.UnknownAbility);
			}
			if (message.Kind == MjolnirNetMessageKind.OwnershipTransferred)
			{
				if (message.SenderPeerId != context.ServerPeerId)
				{
					return NetAdmissionResult.Reject(NetRejectionReason.ServerOnly);
				}
				return NetAdmissionResult.Accept();
			}
			if (message.Kind == MjolnirNetMessageKind.SnapshotRequest)
			{
				return NetAdmissionResult.Accept();
			}
			if (message.SenderPeerId != message.OwnerPeerId)
			{
				return NetAdmissionResult.Reject(NetRejectionReason.NotOwner);
			}
			if (ownsLocally)
			{
				return NetAdmissionResult.Reject(NetRejectionReason.ForeignClaimOnLocalHammer);
			}
			if (!context.HasLocalPlayer)
			{
				return NetAdmissionResult.Reject(NetRejectionReason.NoLocalPlayer);
			}
			return NetAdmissionResult.Accept();
		}
	}
	public enum NetDecodeFailure
	{
		None,
		MalformedLength,
		Truncated,
		VersionMismatch,
		FieldOutOfRange,
		NonFiniteGeometry
	}
	public readonly struct NetDecodeResult
	{
		public bool Success { get; }

		public MjolnirNetMessage Message { get; }

		public NetDecodeFailure Failure { get; }

		private NetDecodeResult(bool success, MjolnirNetMessage message, NetDecodeFailure failure)
		{
			Success = success;
			Message = message;
			Failure = failure;
		}

		public static NetDecodeResult Ok(MjolnirNetMessage message)
		{
			return new NetDecodeResult(success: true, message, NetDecodeFailure.None);
		}

		public static NetDecodeResult Fail(NetDecodeFailure failure)
		{
			return new NetDecodeResult(success: false, default(MjolnirNetMessage), failure);
		}
	}
	public static class MjolnirNetCodec
	{
		[StructLayout(LayoutKind.Explicit)]
		private readonly struct FloatBits
		{
			[FieldOffset(0)]
			private readonly int bits;

			[FieldOffset(0)]
			private readonly float value;

			internal int Bits => bits;

			internal float Value => value;

			internal FloatBits(float value)
			{
				bits = 0;
				this.value = value;
			}

			internal FloatBits(int bits)
			{
				value = 0f;
				this.bits = bits;
			}
		}

		public const int MessageBytes = 139;

		private const MjolnirNetFlags AllFlags = MjolnirNetFlags.Embedded | MjolnirNetFlags.Grounded | MjolnirNetFlags.PlayerFlight | MjolnirNetFlags.LateJoinReplay;

		public static int Encode(in MjolnirNetMessage message, byte[] buffer)
		{
			if (buffer == null)
			{
				throw new ArgumentNullException("buffer");
			}
			if (buffer.Length < 139)
			{
				throw new ArgumentException($"Buffer must hold at least {139} bytes.", "buffer");
			}
			int offset = 0;
			WriteUInt16(buffer, ref offset, message.Version);
			buffer[offset++] = (byte)message.Kind;
			WriteGuid(buffer, ref offset, message.Hammer.HammerId);
			WriteInt32(buffer, ref offset, message.Hammer.Epoch);
			WriteInt64(buffer, ref offset, message.Hammer.LedgerWorldUid);
			WriteInt64(buffer, ref offset, message.SenderPeerId);
			WriteInt64(buffer, ref offset, message.OwnerPeerId);
			WriteInt64(buffer, ref offset, message.Sequence);
			WriteDouble(buffer, ref offset, message.SentAtSeconds);
			buffer[offset++] = (byte)message.State;
			buffer[offset++] = (byte)message.Flags;
			WriteVector(buffer, ref offset, message.Position);
			WriteSingle(buffer, ref offset, message.Rotation.X);
			WriteSingle(buffer, ref offset, message.Rotation.Y);
			WriteSingle(buffer, ref offset, message.Rotation.Z);
			WriteSingle(buffer, ref offset, message.Rotation.W);
			WriteVector(buffer, ref offset, message.Velocity);
			WriteVector(buffer, ref offset, message.Target);
			WriteInt64(buffer, ref offset, message.ActivationId);
			buffer[offset++] = (byte)message.Ability;
			WriteSingle(buffer, ref offset, message.Magnitude);
			buffer[offset++] = message.Detail;
			WriteInt64(buffer, ref offset, message.Claimant);
			return offset;
		}

		public static NetDecodeResult Decode(byte[]? buffer, int length)
		{
			if (buffer == null || length <= 0 || length > 256 || length > buffer.Length)
			{
				return NetDecodeResult.Fail(NetDecodeFailure.MalformedLength);
			}
			if (length < 139)
			{
				return NetDecodeResult.Fail(NetDecodeFailure.Truncated);
			}
			int offset = 0;
			ushort num = ReadUInt16(buffer, ref offset);
			if (num != 2)
			{
				return NetDecodeResult.Fail(NetDecodeFailure.VersionMismatch);
			}
			byte b = buffer[offset++];
			if (!IsDefinedKind(b))
			{
				return NetDecodeResult.Fail(NetDecodeFailure.FieldOutOfRange);
			}
			Guid guid = ReadGuid(buffer, ref offset);
			int num2 = ReadInt32(buffer, ref offset);
			long ledgerWorldUid = ReadInt64(buffer, ref offset);
			if (guid == Guid.Empty || num2 < 0)
			{
				return NetDecodeResult.Fail(NetDecodeFailure.FieldOutOfRange);
			}
			long senderPeerId = ReadInt64(buffer, ref offset);
			long ownerPeerId = ReadInt64(buffer, ref offset);
			long sequence = ReadInt64(buffer, ref offset);
			double sentAtSeconds = ReadDouble(buffer, ref offset);
			byte b2 = buffer[offset++];
			byte b3 = buffer[offset++];
			if (!IsDefinedState(b2) || b3 > 15)
			{
				return NetDecodeResult.Fail(NetDecodeFailure.FieldOutOfRange);
			}
			FlightVector position = ReadVector(buffer, ref offset);
			NetRotation rotation = new NetRotation(ReadSingle(buffer, ref offset), ReadSingle(buffer, ref offset), ReadSingle(buffer, ref offset), ReadSingle(buffer, ref offset));
			FlightVector velocity = ReadVector(buffer, ref offset);
			FlightVector target = ReadVector(buffer, ref offset);
			long activationId = ReadInt64(buffer, ref offset);
			byte ability = buffer[offset++];
			float magnitude = ReadSingle(buffer, ref offset);
			byte detail = buffer[offset++];
			long claimant = ReadInt64(buffer, ref offset);
			MjolnirNetMessage message = new MjolnirNetMessage(num, (MjolnirNetMessageKind)b, new HammerIdentity(guid, num2, ledgerWorldUid), senderPeerId, ownerPeerId, sequence, sentAtSeconds, (MjolnirState)b2, (MjolnirNetFlags)b3, position, rotation, velocity, target, activationId, (MjolnirAbilityCode)ability, magnitude, detail, claimant);
			if (!message.HasFiniteGeometry || !rotation.IsValid)
			{
				return NetDecodeResult.Fail(NetDecodeFailure.NonFiniteGeometry);
			}
			return NetDecodeResult.Ok(message);
		}

		private static bool IsDefinedKind(byte value)
		{
			if (value > 0)
			{
				return value <= 14;
			}
			return false;
		}

		private static bool IsDefinedState(byte value)
		{
			return value <= 19;
		}

		private static void WriteUInt16(byte[] buffer, ref int offset, ushort value)
		{
			buffer[offset++] = (byte)value;
			buffer[offset++] = (byte)(value >> 8);
		}

		private static ushort ReadUInt16(byte[] buffer, ref int offset)
		{
			ushort result = (ushort)(buffer[offset] | (buffer[offset + 1] << 8));
			offset += 2;
			return result;
		}

		private static void WriteInt32(byte[] buffer, ref int offset, int value)
		{
			buffer[offset++] = (byte)value;
			buffer[offset++] = (byte)(value >> 8);
			buffer[offset++] = (byte)(value >> 16);
			buffer[offset++] = (byte)(value >> 24);
		}

		private static int ReadInt32(byte[] buffer, ref int offset)
		{
			int result = buffer[offset] | (buffer[offset + 1] << 8) | (buffer[offset + 2] << 16) | (buffer[offset + 3] << 24);
			offset += 4;
			return result;
		}

		private static void WriteInt64(byte[] buffer, ref int offset, long value)
		{
			for (int i = 0; i < 64; i += 8)
			{
				buffer[offset++] = (byte)(value >> i);
			}
		}

		private static long ReadInt64(byte[] buffer, ref int offset)
		{
			long num = 0L;
			for (int i = 0; i < 8; i++)
			{
				num |= (long)((ulong)buffer[offset + i] << i * 8);
			}
			offset += 8;
			return num;
		}

		private static void WriteSingle(byte[] buffer, ref int offset, float value)
		{
			WriteInt32(buffer, ref offset, SingleToBits(value));
		}

		private static float ReadSingle(byte[] buffer, ref int offset)
		{
			return BitsToSingle(ReadInt32(buffer, ref offset));
		}

		private static void WriteDouble(byte[] buffer, ref int offset, double value)
		{
			WriteInt64(buffer, ref offset, BitConverter.DoubleToInt64Bits(value));
		}

		private static double ReadDouble(byte[] buffer, ref int offset)
		{
			return BitConverter.Int64BitsToDouble(ReadInt64(buffer, ref offset));
		}

		private static void WriteVector(byte[] buffer, ref int offset, FlightVector value)
		{
			WriteSingle(buffer, ref offset, value.X);
			WriteSingle(buffer, ref offset, value.Y);
			WriteSingle(buffer, ref offset, value.Z);
		}

		private static FlightVector ReadVector(byte[] buffer, ref int offset)
		{
			return new FlightVector(ReadSingle(buffer, ref offset), ReadSingle(buffer, ref offset), ReadSingle(buffer, ref offset));
		}

		private static void WriteGuid(byte[] buffer, ref int offset, Guid value)
		{
			byte[] array = value.ToByteArray();
			for (int i = 0; i < 16; i++)
			{
				buffer[offset + i] = array[i];
			}
			offset += 16;
		}

		private static Guid ReadGuid(byte[] buffer, ref int offset)
		{
			int a = buffer[offset] | (buffer[offset + 1] << 8) | (buffer[offset + 2] << 16) | (buffer[offset + 3] << 24);
			short b = (short)(buffer[offset + 4] | (buffer[offset + 5] << 8));
			short c = (short)(buffer[offset + 6] | (buffer[offset + 7] << 8));
			Guid result = new Guid(a, b, c, buffer[offset + 8], buffer[offset + 9], buffer[offset + 10], buffer[offset + 11], buffer[offset + 12], buffer[offset + 13], buffer[offset + 14], buffer[offset + 15]);
			offset += 16;
			return result;
		}

		private static int SingleToBits(float value)
		{
			return new FloatBits(value).Bits;
		}

		private static float BitsToSingle(int bits)
		{
			return new FloatBits(bits).Value;
		}
	}
	[Flags]
	public enum MjolnirNetFlags : byte
	{
		None = 0,
		Embedded = 1,
		Grounded = 2,
		PlayerFlight = 4,
		LateJoinReplay = 8
	}
	public readonly struct MjolnirNetMessage : IEquatable<MjolnirNetMessage>
	{
		public long Claimant { get; }

		public ushort Version { get; }

		public MjolnirNetMessageKind Kind { get; }

		public HammerIdentity Hammer { get; }

		public long SenderPeerId { get; }

		public long OwnerPeerId { get; }

		public long Sequence { get; }

		public double SentAtSeconds { get; }

		public MjolnirState State { get; }

		public MjolnirNetFlags Flags { get; }

		public FlightVector Position { get; }

		public NetRotation Rotation { get; }

		public FlightVector Velocity { get; }

		public FlightVector Target { get; }

		public long ActivationId { get; }

		public MjolnirAbilityCode Ability { get; }

		public float Magnitude { get; }

		public byte Detail { get; }

		public bool HasFiniteGeometry
		{
			get
			{
				if (IsFinite(Position) && IsFinite(Velocity) && IsFinite(Target) && !float.IsNaN(Magnitude) && !float.IsInfinity(Magnitude) && !double.IsNaN(SentAtSeconds))
				{
					return !double.IsInfinity(SentAtSeconds);
				}
				return false;
			}
		}

		public MjolnirNetMessage(ushort version, MjolnirNetMessageKind kind, HammerIdentity hammer, long senderPeerId, long ownerPeerId, long sequence, double sentAtSeconds, MjolnirState state, MjolnirNetFlags flags, FlightVector position, NetRotation rotation, FlightVector velocity, FlightVector target, long activationId, MjolnirAbilityCode ability, float magnitude, byte detail = 0, long claimant = 0L)
		{
			Version = version;
			Kind = kind;
			Hammer = hammer;
			SenderPeerId = senderPeerId;
			OwnerPeerId = ownerPeerId;
			Sequence = sequence;
			SentAtSeconds = sentAtSeconds;
			State = state;
			Flags = flags;
			Position = position;
			Rotation = rotation;
			Velocity = velocity;
			Target = target;
			ActivationId = activationId;
			Ability = ability;
			Magnitude = magnitude;
			Detail = detail;
			Claimant = claimant;
		}

		public MjolnirNetMessage WithFlags(MjolnirNetFlags flags)
		{
			return new MjolnirNetMessage(Version, Kind, Hammer, SenderPeerId, OwnerPeerId, Sequence, SentAtSeconds, State, flags, Position, Rotation, Velocity, Target, ActivationId, Ability, Magnitude, Detail, 0L);
		}

		public MjolnirNetMessage WithKind(MjolnirNetMessageKind kind, long sequence)
		{
			return new MjolnirNetMessage(Version, kind, Hammer, SenderPeerId, OwnerPeerId, sequence, SentAtSeconds, State, Flags, Position, Rotation, Velocity, Target, ActivationId, Ability, Magnitude, Detail, 0L);
		}

		public bool Equals(MjolnirNetMessage other)
		{
			if (Version == other.Version && Kind == other.Kind && Hammer.Equals(other.Hammer) && SenderPeerId == other.SenderPeerId && OwnerPeerId == other.OwnerPeerId && Sequence == other.Sequence && SentAtSeconds.Equals(other.SentAtSeconds) && State == other.State && Flags == other.Flags && Position.Equals(other.Position) && Rotation.Equals(other.Rotation) && Velocity.Equals(other.Velocity) && Target.Equals(other.Target) && ActivationId == other.ActivationId && Ability == other.Ability && Magnitude.Equals(other.Magnitude) && Detail == other.Detail)
			{
				return Claimant == other.Claimant;
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return ((((((((int)Kind * 397) ^ Hammer.GetHashCode()) * 397) ^ SenderPeerId.GetHashCode()) * 397) ^ Sequence.GetHashCode()) * 397) ^ ActivationId.GetHashCode();
		}

		public override string ToString()
		{
			return $"{Kind} hammer={Hammer} owner={OwnerPeerId} sender={SenderPeerId} seq={Sequence} state={State}";
		}

		private static bool IsFinite(FlightVector value)
		{
			if (!float.IsNaN(value.X) && !float.IsInfinity(value.X) && !float.IsNaN(value.Y) && !float.IsInfinity(value.Y) && !float.IsNaN(value.Z))
			{
				return !float.IsInfinity(value.Z);
			}
			return false;
		}
	}
	public enum MjolnirNetMessageKind : byte
	{
		None,
		SnapshotRequest,
		Snapshot,
		HammerState,
		ThrowCommitted,
		RecallStarted,
		HammerCaught,
		ImpactConfirmed,
		AbilityTriggered,
		FlightEntered,
		FlightExited,
		HammerReleased,
		OwnershipTransferred,
		HammerPresence,
		ReclaimRequested
	}
	public static class MjolnirNetProtocol
	{
		public const ushort Version = 2;

		public const string RpcName = "ValheimMjolnir.Net.v1";

		public const int MaximumMessageBytes = 256;

		public const float StateBroadcastInterval = 0.1f;

		public const float MirrorStaleSeconds = 1f;

		public const float PresenceBroadcastInterval = 2f;

		public const float PresenceStaleSeconds = 7f;

		public const long NoPeer = 0L;

		public const long EveryPeer = 0L;

		public static readonly Guid SessionHammerId = new Guid("6a1d0f4c-9b3e-4a27-8f51-0e1c7b6d24aa");

		public static bool IsSessionScoped(MjolnirNetMessageKind kind)
		{
			if (kind == MjolnirNetMessageKind.SnapshotRequest || kind == MjolnirNetMessageKind.ReclaimRequested)
			{
				return true;
			}
			return false;
		}

		public static bool IsDiscrete(MjolnirNetMessageKind kind)
		{
			return kind switch
			{
				MjolnirNetMessageKind.ThrowCommitted => true, 
				MjolnirNetMessageKind.RecallStarted => true, 
				MjolnirNetMessageKind.HammerCaught => true, 
				MjolnirNetMessageKind.ImpactConfirmed => true, 
				MjolnirNetMessageKind.AbilityTriggered => true, 
				MjolnirNetMessageKind.FlightEntered => true, 
				MjolnirNetMessageKind.FlightExited => true, 
				MjolnirNetMessageKind.OwnershipTransferred => true, 
				MjolnirNetMessageKind.ReclaimRequested => true, 
				_ => false, 
			};
		}
	}
	public sealed class MjolnirNetSession
	{
		private readonly struct PresenceRecord
		{
			internal long OwnerPeerId { get; }

			internal double UpdatedAtSeconds { get; }

			internal PresenceRecord(long ownerPeerId, double updatedAtSeconds)
			{
				OwnerPeerId = ownerPeerId;
				UpdatedAtSeconds = updatedAtSeconds;
			}
		}

		private readonly Dictionary<HammerIdentity, RemoteHammerSnapshot> mirrors = new Dictionary<HammerIdentity, RemoteHammerSnapshot>();

		private readonly Dictionary<HammerIdentity, PresenceRecord> presence = new Dictionary<HammerIdentity, PresenceRecord>();

		private readonly Dictionary<HammerIdentity, long> outboundSequences = new Dictionary<HammerIdentity, long>();

		private readonly NetSequenceGate sequences = new NetSequenceGate();

		private readonly NetActivationGate activations;

		private NetPeerContext context;

		private long nextActivationId;

		public NetPeerContext Context => context;

		public int MirrorCount => mirrors.Count;

		public int RemoteHammerCount => presence.Count;

		public IEnumerable<RemoteHammerSnapshot> Mirrors => mirrors.Values;

		public event Action<MjolnirNetMessage, NetRejectionReason>? Rejected;

		public MjolnirNetSession(NetPeerContext context, int activationMemory = 256)
		{
			this.context = context;
			activations = new NetActivationGate(activationMemory);
		}

		public void UpdateContext(NetPeerContext updated)
		{
			bool num = updated.WorldUid != context.WorldUid || updated.LocalPeerId != context.LocalPeerId || updated.Role != context.Role;
			context = updated;
			if (num)
			{
				Reset();
			}
		}

		public void Reset()
		{
			mirrors.Clear();
			presence.Clear();
			outboundSequences.Clear();
			sequences.Clear();
			activations.Clear();
		}

		public NetReceiveOutcome Receive(in MjolnirNetMessage message, double nowSeconds, bool ownsLocally)
		{
			NetAdmissionResult netAdmissionResult = MjolnirNetAdmissionPolicy.Evaluate(in message, in context, ownsLocally);
			if (!netAdmissionResult.Accepted)
			{
				return Refuse(in message, netAdmissionResult.Reason);
			}
			NetRejectionReason netRejectionReason = sequences.Admit(in message);
			if (netRejectionReason != NetRejectionReason.None)
			{
				return Refuse(in message, netRejectionReason);
			}
			if (MjolnirNetProtocol.IsDiscrete(message.Kind) && !activations.TryClaim(message.ActivationId))
			{
				return Refuse(in message, NetRejectionReason.Duplicate);
			}
			if (!MjolnirNetProtocol.IsSessionScoped(message.Kind) && message.OwnerPeerId != context.LocalPeerId)
			{
				presence[message.Hammer] = new PresenceRecord(message.OwnerPeerId, nowSeconds);
			}
			switch (message.Kind)
			{
			case MjolnirNetMessageKind.SnapshotRequest:
				return NetReceiveOutcome.Act(NetReceiveAction.AnswerSnapshotRequest);
			case MjolnirNetMessageKind.ReclaimRequested:
				return NetReceiveOutcome.Act(NetReceiveAction.ReleaseReclaimedHammer);
			case MjolnirNetMessageKind.HammerPresence:
				return NetReceiveOutcome.Act(NetReceiveAction.None);
			case MjolnirNetMessageKind.Snapshot:
			case MjolnirNetMessageKind.HammerState:
				return ApplyState(in message, nowSeconds, NetReceiveAction.UpdateMirror);
			case MjolnirNetMessageKind.ThrowCommitted:
				return ApplyState(in message, nowSeconds, NetReceiveAction.PlayThrow);
			case MjolnirNetMessageKind.RecallStarted:
				return ApplyState(in message, nowSeconds, NetReceiveAction.PlayRecall);
			case MjolnirNetMessageKind.HammerCaught:
				Forget(message.Hammer);
				return NetReceiveOutcome.Act(NetReceiveAction.PlayCatch);
			case MjolnirNetMessageKind.HammerReleased:
				Forget(message.Hammer);
				return NetReceiveOutcome.Act(NetReceiveAction.RemoveMirror);
			case MjolnirNetMessageKind.ImpactConfirmed:
				ApplyState(in message, nowSeconds, NetReceiveAction.UpdateMirror);
				return NetReceiveOutcome.Act(NetReceiveAction.PlayImpact);
			case MjolnirNetMessageKind.AbilityTriggered:
				return NetReceiveOutcome.Act(NetReceiveAction.PlayAbility);
			case MjolnirNetMessageKind.FlightEntered:
				return ApplyState(in message, nowSeconds, NetReceiveAction.BeginRemoteFlight);
			case MjolnirNetMessageKind.FlightExited:
				return ApplyState(in message, nowSeconds, NetReceiveAction.EndRemoteFlight);
			case MjolnirNetMessageKind.OwnershipTransferred:
				TransferOwnership(in message, nowSeconds);
				return NetReceiveOutcome.Act(NetReceiveAction.ApplyOwnershipTransfer);
			default:
				return Refuse(in message, NetRejectionReason.UnknownKind);
			}
		}

		public bool TryGetMirror(HammerIdentity hammer, out RemoteHammerSnapshot snapshot)
		{
			return mirrors.TryGetValue(hammer, out snapshot);
		}

		public int SweepStaleMirrors(double nowSeconds, List<HammerIdentity> evicted)
		{
			if (evicted == null)
			{
				throw new ArgumentNullException("evicted");
			}
			evicted.Clear();
			foreach (KeyValuePair<HammerIdentity, RemoteHammerSnapshot> mirror in mirrors)
			{
				if (nowSeconds - mirror.Value.UpdatedAtSeconds >= 1.0)
				{
					evicted.Add(mirror.Key);
				}
			}
			for (int i = 0; i < evicted.Count; i++)
			{
				Forget(evicted[i]);
			}
			return evicted.Count;
		}

		public int ForgetPeer(long peerId, List<HammerIdentity> evicted)
		{
			if (evicted == null)
			{
				throw new ArgumentNullException("evicted");
			}
			evicted.Clear();
			foreach (KeyValuePair<HammerIdentity, RemoteHammerSnapshot> mirror in mirrors)
			{
				if (mirror.Value.OwnerPeerId == peerId)
				{
					evicted.Add(mirror.Key);
				}
			}
			for (int i = 0; i < evicted.Count; i++)
			{
				mirrors.Remove(evicted[i]);
			}
			ForgetPeerPresence(peerId);
			sequences.ForgetSender(peerId);
			return evicted.Count;
		}

		public int SweepStalePresence(double nowSeconds, List<HammerIdentity> evicted)
		{
			if (evicted == null)
			{
				throw new ArgumentNullException("evicted");
			}
			evicted.Clear();
			foreach (KeyValuePair<HammerIdentity, PresenceRecord> item in presence)
			{
				if (nowSeconds - item.Value.UpdatedAtSeconds >= 7.0)
				{
					evicted.Add(item.Key);
				}
			}
			for (int i = 0; i < evicted.Count; i++)
			{
				presence.Remove(evicted[i]);
			}
			return evicted.Count;
		}

		public bool ForgetPresence(HammerIdentity hammer)
		{
			return presence.Remove(hammer);
		}

		private void ForgetPeerPresence(long peerId)
		{
			List<HammerIdentity> list = null;
			foreach (KeyValuePair<HammerIdentity, PresenceRecord> item in presence)
			{
				if (item.Value.OwnerPeerId == peerId)
				{
					(list ?? (list = new List<HammerIdentity>())).Add(item.Key);
				}
			}
			if (list != null)
			{
				for (int i = 0; i < list.Count; i++)
				{
					presence.Remove(list[i]);
				}
			}
		}

		public MjolnirNetMessage BuildSnapshotRequest(double nowSeconds)
		{
			HammerIdentity hammer = new HammerIdentity(MjolnirNetProtocol.SessionHammerId, 0, context.WorldUid);
			return new MjolnirNetMessage(2, MjolnirNetMessageKind.SnapshotRequest, hammer, context.LocalPeerId, 0L, NextSequence(hammer), nowSeconds, MjolnirState.Unavailable, MjolnirNetFlags.None, FlightVector.Zero, NetRotation.Identity, FlightVector.Zero, FlightVector.Zero, 0L, MjolnirAbilityCode.None, 0f, 0, 0L);
		}

		public MjolnirNetMessage BuildReclaimRequest(long claimantCharacterId, double nowSeconds)
		{
			HammerIdentity hammer = new HammerIdentity(MjolnirNetProtocol.SessionHammerId, 0, context.WorldUid);
			return new MjolnirNetMessage(2, MjolnirNetMessageKind.ReclaimRequested, hammer, context.LocalPeerId, context.LocalPeerId, NextSequence(hammer), nowSeconds, MjolnirState.Unavailable, MjolnirNetFlags.None, FlightVector.Zero, NetRotation.Identity, FlightVector.Zero, FlightVector.Zero, NextActivationId(), MjolnirAbilityCode.None, 0f, 0, claimantCharacterId);
		}

		public MjolnirNetMessage BuildStateMessage(MjolnirNetMessageKind kind, HammerIdentity hammer, MjolnirState state, MjolnirNetFlags flags, FlightVector position, NetRotation rotation, FlightVector velocity, double nowSeconds)
		{
			if (kind == MjolnirNetMessageKind.Snapshot)
			{
				flags |= MjolnirNetFlags.LateJoinReplay;
			}
			return new MjolnirNetMessage(2, kind, hammer, context.LocalPeerId, context.LocalPeerId, NextSequence(hammer), nowSeconds, state, flags, position, rotation, velocity, FlightVector.Zero, 0L, MjolnirAbilityCode.None, 0f, 0, 0L);
		}

		public MjolnirNetMessage BuildDiscreteMessage(MjolnirNetMessageKind kind, HammerIdentity hammer, MjolnirState state, MjolnirNetFlags flags, FlightVector position, NetRotation rotation, FlightVector velocity, FlightVector target, double nowSeconds, MjolnirAbilityCode ability = MjolnirAbilityCode.None, float magnitude = 0f, byte detail = 0)
		{
			return new MjolnirNetMessage(2, kind, hammer, context.LocalPeerId, context.LocalPeerId, NextSequence(hammer), nowSeconds, state, flags, position, rotation, velocity, target, NextActivationId(), ability, magnitude, detail, 0L);
		}

		public long NextActivationId()
		{
			nextActivationId++;
			return ((context.LocalPeerId & 0xFFFFFF) << 40) | (nextActivationId & 0xFFFFFFFFFFL);
		}

		private long NextSequence(HammerIdentity hammer)
		{
			outboundSequences.TryGetValue(hammer, out var value);
			value++;
			outboundSequences[hammer] = value;
			return value;
		}

		private NetReceiveOutcome ApplyState(in MjolnirNetMessage message, double nowSeconds, NetReceiveAction action)
		{
			RemoteHammerSnapshot snapshot = new RemoteHammerSnapshot(message.Hammer, message.OwnerPeerId, message.State, message.Flags, message.Position, message.Rotation.Normalized, message.Velocity, nowSeconds);
			if (!snapshot.IsInWorld)
			{
				Forget(message.Hammer);
				return NetReceiveOutcome.Act((action == NetReceiveAction.UpdateMirror) ? NetReceiveAction.RemoveMirror : action, in snapshot);
			}
			mirrors[message.Hammer] = snapshot;
			if ((message.Flags & MjolnirNetFlags.LateJoinReplay) != MjolnirNetFlags.None && action != NetReceiveAction.UpdateMirror)
			{
				return NetReceiveOutcome.Act(NetReceiveAction.UpdateMirror, in snapshot);
			}
			return NetReceiveOutcome.Act(action, in snapshot);
		}

		private void TransferOwnership(in MjolnirNetMessage message, double nowSeconds)
		{
			if (mirrors.TryGetValue(message.Hammer, out var value))
			{
				if (message.OwnerPeerId == context.LocalPeerId)
				{
					Forget(message.Hammer);
					presence.Remove(message.Hammer);
				}
				else
				{
					mirrors[message.Hammer] = new RemoteHammerSnapshot(value.Hammer, message.OwnerPeerId, value.State, value.Flags, value.Position, value.Rotation, value.Velocity, nowSeconds);
				}
			}
		}

		private void Forget(HammerIdentity hammer)
		{
			mirrors.Remove(hammer);
		}

		private NetReceiveOutcome Refuse(in MjolnirNetMessage message, NetRejectionReason reason)
		{
			this.Rejected?.Invoke(message, reason);
			return NetReceiveOutcome.Reject(reason);
		}
	}
	public sealed class NetActivationGate
	{
		private readonly int capacity;

		private readonly HashSet<long> seen;

		private readonly Queue<long> order;

		public int Count => seen.Count;

		public NetActivationGate(int capacity = 256)
		{
			this.capacity = ((capacity < 1) ? 1 : capacity);
			seen = new HashSet<long>();
			order = new Queue<long>(this.capacity);
		}

		public bool TryClaim(long activationId)
		{
			if (activationId == 0L || !seen.Add(activationId))
			{
				return false;
			}
			order.Enqueue(activationId);
			while (order.Count > capacity)
			{
				seen.Remove(order.Dequeue());
			}
			return true;
		}

		public bool HasSeen(long activationId)
		{
			return seen.Contains(activationId);
		}

		public void Clear()
		{
			seen.Clear();
			order.Clear();
		}
	}
	public enum NetRejectionReason
	{
		None,
		NotNetworked,
		UnknownKind,
		WrongWorld,
		SelfEcho,
		NotOwner,
		ForeignClaimOnLocalHammer,
		ServerOnly,
		MissingActivationId,
		UnknownAbility,
		Duplicate,
		Stale,
		ScopeMismatch,
		NoLocalPlayer
	}
	public readonly struct NetAdmissionResult
	{
		public bool Accepted { get; }

		public NetRejectionReason Reason { get; }

		private NetAdmissionResult(bool accepted, NetRejectionReason reason)
		{
			Accepted = accepted;
			Reason = reason;
		}

		public static NetAdmissionResult Accept()
		{
			return new NetAdmissionResult(accepted: true, NetRejectionReason.None);
		}

		public static NetAdmissionResult Reject(NetRejectionReason reason)
		{
			return new NetAdmissionResult(accepted: false, reason);
		}

		public override string ToString()
		{
			if (!Accepted)
			{
				return $"rejected:{Reason}";
			}
			return "accepted";
		}
	}
	public enum NetPeerRole
	{
		Standalone,
		Client,
		ListenHost,
		DedicatedServer
	}
	public readonly struct NetPeerContext
	{
		public NetPeerRole Role { get; }

		public long LocalPeerId { get; }

		public long ServerPeerId { get; }

		public long WorldUid { get; }

		public bool IsServer
		{
			get
			{
				NetPeerRole role = Role;
				if ((uint)(role - 2) <= 1u)
				{
					return true;
				}
				return false;
			}
		}

		public bool HasLocalPlayer
		{
			get
			{
				NetPeerRole role = Role;
				if ((uint)role <= 2u)
				{
					return true;
				}
				return false;
			}
		}

		public bool IsNetworked => Role != NetPeerRole.Standalone;

		public NetPeerContext(NetPeerRole role, long localPeerId, long serverPeerId, long worldUid)
		{
			Role = role;
			LocalPeerId = localPeerId;
			ServerPeerId = serverPeerId;
			WorldUid = worldUid;
		}
	}
	public enum NetReceiveAction
	{
		None,
		UpdateMirror,
		RemoveMirror,
		PlayThrow,
		PlayRecall,
		PlayCatch,
		PlayImpact,
		PlayAbility,
		BeginRemoteFlight,
		EndRemoteFlight,
		AnswerSnapshotRequest,
		ApplyOwnershipTransfer,
		ReleaseReclaimedHammer
	}
	public readonly struct NetReceiveOutcome
	{
		public bool Accepted { get; }

		public NetRejectionReason Reason { get; }

		public NetReceiveAction Action { get; }

		public RemoteHammerSnapshot Snapshot { get; }

		public bool HasSnapshot { get; }

		private NetReceiveOutcome(bool accepted, NetRejectionReason reason, NetReceiveAction action, RemoteHammerSnapshot snapshot, bool hasSnapshot)
		{
			Accepted = accepted;
			Reason = reason;
			Action = action;
			Snapshot = snapshot;
			HasSnapshot = hasSnapshot;
		}

		public static NetReceiveOutcome Act(NetReceiveAction action, in RemoteHammerSnapshot snapshot)
		{
			return new NetReceiveOutcome(accepted: true, NetRejectionReason.None, action, snapshot, hasSnapshot: true);
		}

		public static NetReceiveOutcome Act(NetReceiveAction action)
		{
			return new NetReceiveOutcome(accepted: true, NetRejectionReason.None, action, default(RemoteHammerSnapshot), hasSnapshot: false);
		}

		public static NetReceiveOutcome Reject(NetRejectionReason reason)
		{
			return new NetReceiveOutcome(accepted: false, reason, NetReceiveAction.None, default(RemoteHammerSnapshot), hasSnapshot: false);
		}

		public override string ToString()
		{
			if (!Accepted)
			{
				return $"rejected:{Reason}";
			}
			return $"accepted:{Action}";
		}
	}
	public readonly struct NetRotation : IEquatable<NetRotation>
	{
		public readonly float X;

		public readonly float Y;

		public readonly float Z;

		public readonly float W;

		public static NetRotation Identity => new NetRotation(0f, 0f, 0f, 1f);

		public bool IsValid
		{
			get
			{
				float num = X * X + Y * Y + Z * Z + W * W;
				if (!float.IsNaN(num) && !float.IsInfinity(num))
				{
					return num > 1E-06f;
				}
				return false;
			}
		}

		public NetRotation Normalized
		{
			get
			{
				if (!IsValid)
				{
					return Identity;
				}
				float num = (float)Math.Sqrt(X * X + Y * Y + Z * Z + W * W);
				return new NetRotation(X / num, Y / num, Z / num, W / num);
			}
		}

		public NetRotation(float x, float y, float z, float w)
		{
			X = x;
			Y = y;
			Z = z;
			W = w;
		}

		public bool Equals(NetRotation other)
		{
			float x = X;
			if (x.Equals(other.X))
			{
				x = Y;
				if (x.Equals(other.Y))
				{
					x = Z;
					if (x.Equals(other.Z))
					{
						x = W;
						return x.Equals(other.W);
					}
				}
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			float x = X;
			int num = x.GetHashCode() * 397;
			x = Y;
			int num2 = (num ^ x.GetHashCode()) * 397;
			x = Z;
			int num3 = (num2 ^ x.GetHashCode()) * 397;
			x = W;
			return num3 ^ x.GetHashCode();
		}

		public override string ToString()
		{
			return $"({X:0.###}, {Y:0.###}, {Z:0.###}, {W:0.###})";
		}
	}
	public sealed class NetSequenceGate
	{
		private readonly struct Key : IEquatable<Key>
		{
			internal long Sender { get; }

			internal HammerIdentity Hammer { get; }

			internal MjolnirNetMessageKind Kind { get; }

			internal Key(long sender, HammerIdentity hammer, MjolnirNetMessageKind kind)
			{
				Sender = sender;
				Hammer = hammer;
				Kind = kind;
			}

			public bool Equals(Key other)
			{
				if (Sender == other.Sender && Kind == other.Kind)
				{
					return Hammer.Equals(other.Hammer);
				}
				return false;
			}

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

			public override int GetHashCode()
			{
				return (((Sender.GetHashCode() * 397) ^ Hammer.GetHashCode()) * 397) ^ (int)Kind;
			}
		}

		private readonly Dictionary<Key, long> highest = new Dictionary<Key, long>();

		public int TrackedStreams => highest.Count;

		public NetRejectionReason Admit(in MjolnirNetMessage message)
		{
			if (message.Sequence == 0L)
			{
				return NetRejectionReason.None;
			}
			Key key = new Key(message.SenderPeerId, message.Hammer, message.Kind);
			if (!highest.TryGetValue(key, out var value))
			{
				highest[key] = message.Sequence;
				return NetRejectionReason.None;
			}
			if (message.Sequence == value)
			{
				return NetRejectionReason.Duplicate;
			}
			if (message.Sequence < value)
			{
				return NetRejectionReason.Stale;
			}
			highest[key] = message.Sequence;
			return NetRejectionReason.None;
		}

		public int ForgetSender(long senderPeerId)
		{
			List<Key> list = null;
			foreach (KeyValuePair<Key, long> item in highest)
			{
				if (item.Key.Sender == senderPeerId)
				{
					(list ?? (list = new List<Key>())).Add(item.Key);
				}
			}
			if (list == null)
			{
				return 0;
			}
			for (int i = 0; i < list.Count; i++)
			{
				highest.Remove(list[i]);
			}
			return list.Count;
		}

		public void Clear()
		{
			highest.Clear();
		}
	}
	public readonly struct RemoteHammerSnapshot
	{
		public HammerIdentity Hammer { get; }

		public long OwnerPeerId { get; }

		public MjolnirState State { get; }

		public MjolnirNetFlags Flags { get; }

		public FlightVector Position { get; }

		public NetRotation Rotation { get; }

		public FlightVector Velocity { get; }

		public double UpdatedAtSeconds { get; }

		public bool IsInWorld => State switch
		{
			MjolnirState.ThrownOutbound => true, 
			MjolnirState.Embedded => true, 
			MjolnirState.EmbeddedInEnemy => true, 
			MjolnirState.Returning => true, 
			MjolnirState.Recalling => true, 
			MjolnirState.Dropped => true, 
			MjolnirState.Orbiting => true, 
			MjolnirState.Planted => true, 
			MjolnirState.CrosshairControlled => true, 
			MjolnirState.Levitating => true, 
			_ => false, 
		};

		public bool IsPlayerFlight => (Flags & MjolnirNetFlags.PlayerFlight) != 0;

		public RemoteHammerSnapshot(HammerIdentity hammer, long ownerPeerId, MjolnirState state, MjolnirNetFlags flags, FlightVector position, NetRotation rotation, FlightVector velocity, double updatedAtSeconds)
		{
			Hammer = hammer;
			OwnerPeerId = ownerPeerId;
			State = state;
			Flags = flags;
			Position = position;
			Rotation = rotation;
			Velocity = velocity;
			UpdatedAtSeconds = updatedAtSeconds;
		}

		public RemoteHammerSnapshot WithMotion(MjolnirState state, MjolnirNetFlags flags, FlightVector position, NetRotation rotation, FlightVector velocity, double updatedAtSeconds)
		{
			return new RemoteHammerSnapshot(Hammer, OwnerPeerId, state, flags, position, rotation, velocity, updatedAtSeconds);
		}

		public FlightVector Extrapolate(double elapsedSeconds, float maximumSeconds = 0.5f)
		{
			if (elapsedSeconds <= 0.0)
			{
				return Position;
			}
			float num = (float)((elapsedSeconds > (double)maximumSeconds) ? ((double)maximumSeconds) : elapsedSeconds);
			return Position + Velocity * num;
		}

		public override string ToString()
		{
			return $"hammer={Hammer} owner={OwnerPeerId} state={State} flags={Flags}";
		}
	}
}
namespace ValheimMjolnir.Core.Identity
{
	public enum HammerClaim
	{
		None,
		Unclaimed,
		Owner,
		Borrower
	}
	public static class HammerClaimPolicy
	{
		public static HammerClaim Classify(string? ownerId, string? borrowerId, string? characterId)
		{
			if (string.IsNullOrWhiteSpace(characterId))
			{
				return HammerClaim.None;
			}
			if (string.IsNullOrWhiteSpace(ownerId))
			{
				return HammerClaim.Unclaimed;
			}
			if (Same(ownerId, characterId))
			{
				return HammerClaim.Owner;
			}
			if (!Same(borrowerId, characterId))
			{
				return HammerClaim.None;
			}
			return HammerClaim.Borrower;
		}

		public static bool PermitsUse(HammerClaim claim)
		{
			if ((uint)(claim - 1) <= 2u)
			{
				return true;
			}
			return false;
		}

		private static bool Same(string? left, string? right)
		{
			if (!string.IsNullOrWhiteSpace(left) && !string.IsNullOrWhiteSpace(right))
			{
				return string.Equals(left, right, StringComparison.Ordinal);
			}
			return false;
		}
	}
	public readonly struct HammerIdentity : IEquatable<HammerIdentity>
	{
		public Guid HammerId { get; }

		public int Epoch { get; }

		public long LedgerWorldUid { get; }

		public HammerIdentity(Guid hammerId, int epoch, long ledgerWorldUid)
		{
			if (hammerId == Guid.Empty)
			{
				throw new ArgumentException("Hammer ID cannot be empty.", "hammerId");
			}
			if (epoch < 0)
			{
				throw new ArgumentOutOfRangeException("epoch");
			}
			HammerId = hammerId;
			Epoch = epoch;
			LedgerWorldUid = ledgerWorldUid;
		}

		public HammerIdentity NextEpoch()
		{
			return new HammerIdentity(HammerId, checked(Epoch + 1), LedgerWorldUid);
		}

		public bool Equals(HammerIdentity other)
		{
			if (HammerId.Equals(other.HammerId) && Epoch == other.Epoch)
			{
				return LedgerWorldUid == other.LedgerWorldUid;
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return (((HammerId.GetHashCode() * 397) ^ Epoch) * 397) ^ LedgerWorldUid.GetHashCode();
		}

		public override string ToString()
		{
			return $"{HammerId:N}:{Epoch}:{LedgerWorldUid}";
		}
	}
	public static class HammerIdentityCodec
	{
		private sealed class DictionaryView : IReadOnlyDictionary<string, string>, IReadOnlyCollection<KeyValuePair<string, string>>, IEnumerable<KeyValuePair<string, string>>, IEnumerable
		{
			private readonly IDictionary<string, string> source;

			public int Count => source.Count;

			public IEnumerable<string> Keys => source.Keys;

			public IEnumerable<string> Values => source.Values;

			public string this[string key] => source[key];

			internal DictionaryView(IDictionary<string, string> source)
			{
				this.source = source;
			}

			public bool ContainsKey(string key)
			{
				return source.ContainsKey(key);
			}

			public bool TryGetValue(string key, out string value)
			{
				return source.TryGetValue(key, out value);
			}

			public IEnumerator<KeyValuePair<string, string>> GetEnumerator()
			{
				return source.GetEnumerator();
			}

			IEnumerator IEnumerable.GetEnumerator()
			{
				return GetEnumerator();
			}
		}

		private const int LegacySchema = 2;

		public static HammerIdentityParseResult Read(IReadOnlyDictionary<string, string> data)
		{
			if (!data.TryGetValue("com.kewb.valheimmjolnir.schema", out string value))
			{
				return Reject(HammerIdentityParseStatus.MissingSchema);
			}
			if (!int.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
			{
				return Reject(HammerIdentityParseStatus.MalformedSchema);
			}
			if (result != 2 && result != 3)
			{
				return Reject(HammerIdentityParseStatus.UnsupportedSchema);
			}
			if (!data.TryGetValue("com.kewb.valheimmjolnir.id", out string value2) || string.IsNullOrWhiteSpace(value2))
			{
				return Reject(HammerIdentityParseStatus.MissingIdentity);
			}
			if (!Guid.TryParseExact(value2, "N", out var result2) || result2 == Guid.Empty)
			{
				return Reject(HammerIdentityParseStatus.MalformedIdentity);
			}
			if (!data.TryGetValue("com.kewb.valheimmjolnir.epoch", out string value3) || !int.TryParse(value3, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result3) || result3 < 0)
			{
				return Reject(HammerIdentityParseStatus.InvalidEpoch);
			}
			string value4;
			bool result4 = default(bool);
			bool isProvisional = data.TryGetValue("com.kewb.valheimmjolnir.provisional", out value4) && bool.TryParse(value4, out result4) && result4;
			long? worldUid = null;
			if (result == 3 && data.TryGetValue("com.kewb.valheimmjolnir.world_uid", out string value5) && long.TryParse(value5, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result5) && result5 != 0L)
			{
				worldUid = result5;
			}
			return new HammerIdentityParseResult((result == 2) ? HammerIdentityParseStatus.LegacyUnbound : ((!worldUid.HasValue) ? HammerIdentityParseStatus.CurrentUnbound : HammerIdentityParseStatus.CurrentBound), new HammerIdentityEnvelope(result, result2, result3, worldUid, isProvisional));
		}

		public static HammerIdentityMigrationResult MigrateToCurrent(IDictionary<string, string> data, long? worldUid, Func<Guid>? idFactory = null)
		{
			HammerIdentityParseResult hammerIdentityParseResult = Read((data as IReadOnlyDictionary<string, string>) ?? new DictionaryView(data));
			if (hammerIdentityParseResult.Status == HammerIdentityParseStatus.UnsupportedSchema)
			{
				return RejectMigration(HammerIdentityMigrationFailure.UnsupportedSchema, hammerIdentityParseResult);
			}
			HammerIdentityEnvelope envelope = hammerIdentityParseResult.Envelope;
			bool flag = false;
			Guid guid;
			int num;
			if (envelope != null)
			{
				guid = envelope.HammerId;
				num = envelope.Epoch;
				if (worldUid.HasValue && worldUid.Value != 0L && envelope.IsWorldBound && envelope.WorldUid != worldUid)
				{
					return RejectMigration(HammerIdentityMigrationFailure.ForeignWorld, hammerIdentityParseResult);
				}
			}
			else
			{
				if (idFactory == null)
				{
					return RejectMigration(HammerIdentityMigrationFailure.InvalidSource, hammerIdentityParseResult);
				}
				guid = idFactory();
				if (guid == Guid.Empty)
				{
					return RejectMigration(HammerIdentityMigrationFailure.InvalidGeneratedIdentity, hammerIdentityParseResult);
				}
				num = 0;
				flag = true;
			}
			long? num2 = ((envelope != null && envelope.IsWorldBound) ? envelope.WorldUid : worldUid);
			string value = guid.ToString("N");
			string value2 = num.ToString(CultureInfo.InvariantCulture);
			string value3 = 3.ToString(CultureInfo.InvariantCulture);
			bool flag2 = Set(data, "com.kewb.valheimmjolnir.id", value) | Set(data, "com.kewb.valheimmjolnir.epoch", value2) | Set(data, "com.kewb.valheimmjolnir.schema", value3);
			flag2 = ((!num2.HasValue || num2.Value == 0L) ? (flag2 | data.Remove("com.kewb.valheimmjolnir.world_uid")) : (flag2 | Set(data, "com.kewb.valheimmjolnir.world_uid", num2.Value.ToString(CultureInfo.InvariantCulture))));
			if (flag)
			{
				flag2 |= Set(data, "com.kewb.valheimmjolnir.provisional", bool.TrueString.ToLowerInvariant());
			}
			HammerIdentityParseResult parseResult = Read((data as IReadOnlyDictionary<string, string>) ?? new DictionaryView(data));
			return new HammerIdentityMigrationResult(accepted: true, flag2, HammerIdentityMigrationFailure.None, parseResult);
		}

		public static void WriteBoundIdentity(IDictionary<string, string> data, HammerIdentity identity)
		{
			if (identity.LedgerWorldUid == 0L)
			{
				throw new ArgumentOutOfRangeException("identity", "A bound identity requires a nonzero world UID.");
			}
			data["com.kewb.valheimmjolnir.id"] = identity.HammerId.ToString("N");
			data["com.kewb.valheimmjolnir.epoch"] = identity.Epoch.ToString(CultureInfo.InvariantCulture);
			data["com.kewb.valheimmjolnir.world_uid"] = identity.LedgerWorldUid.ToString(CultureInfo.InvariantCulture);
			data["com.kewb.valheimmjolnir.schema"] = 3.ToString(CultureInfo.InvariantCulture);
			data.Remove("com.kewb.valheimmjolnir.provisional");
		}

		private static HammerIdentityParseResult Reject(HammerIdentityParseStatus status)
		{
			return new HammerIdentityParseResult(status, null);
		}

		private static HammerIdentityMigrationResult RejectMigration(HammerIdentityMigrationFailure failure, HammerIdentityParseResult parsed)
		{
			return new HammerIdentityMigrationResult(accepted: false, changed: false, failure, parsed);
		}

		private static bool Set(IDictionary<string, string> data, string key, string value)
		{
			if (data.TryGetValue(key, out string value2) && string.Equals(value2, value, StringComparison.Ordinal))
			{
				return false;
			}
			data[key] = value;
			return true;
		}
	}
	public sealed class HammerIdentityEnvelope
	{
		public int Schema { get; }

		public Guid HammerId { get; }

		public int Epoch { get; }

		public long? WorldUid { get; }

		public bool IsProvisional { get; }

		public bool IsWorldBound
		{
			get
			{
				if (WorldUid.HasValue)
				{
					return WorldUid.Value != 0;
				}
				return false;
			}
		}

		internal HammerIdentityEnvelope(int schema, Guid hammerId, int epoch, long? worldUid, bool isProvisional)
		{
			Schema = schema;
			HammerId = hammerId;
			Epoch = epoch;
			WorldUid = worldUid;
			IsProvisional = isProvisional;
		}

		public bool TryGetBoundIdentity(out HammerIdentity identity)
		{
			if (IsWorldBound)
			{
				identity = new HammerIdentity(HammerId, Epoch, WorldUid.Value);
				return true;
			}
			identity = default(HammerIdentity);
			return false;
		}
	}
	public enum HammerIdentityMigrationFailure
	{
		None,
		InvalidSource,
		UnsupportedSchema,
		ForeignWorld,
		InvalidGeneratedIdentity
	}
	public sealed class HammerIdentityMigrationResult
	{
		public bool Accepted { get; }

		public bool Changed { get; }

		public HammerIdentityMigrationFailure Failure { get; }

		public HammerIdentityParseResult ParseResult { get; }

		internal HammerIdentityMigrationResult(bool accepted, bool changed, HammerIdentityMigrationFailure failure, HammerIdentityParseResult parseResult)
		{
			Accepted = accepted;
			Changed = changed;
			Failure = failure;
			ParseResult = parseResult;
		}
	}
	public enum HammerIdentityParseStatus
	{
		CurrentBound,
		CurrentUnbound,
		LegacyUnbound,
		MissingSchema,
		MalformedSchema,
		UnsupportedSchema,
		MissingIdentity,
		MalformedIdentity,
		InvalidEpoch
	}
	public sealed class HammerIdentityParseResult
	{
		public HammerIdentityParseStatus Status { get; }

		public HammerIdentityEnvelope? Envelope { get; }

		public bool Accepted => Envelope != null;

		internal HammerIdentityParseResult(HammerIdentityParseStatus status, HammerIdentityEnvelope? envelope)
		{
			Status = status;
			Envelope = envelope;
		}

		public bool IsForeignTo(long worldUid)
		{
			if (worldUid != 0L)
			{
				HammerIdentityEnvelope? envelope = Envelope;
				if (envelope != null && envelope.IsWorldBound)
				{
					return Envelope.WorldUid != worldUid;
				}
			}
			return false;
		}
	}
	public static class HammerIdentitySchema
	{
		public const int Current = 3;

		public const string IdKey = "com.kewb.valheimmjolnir.id";

		public const string EpochKey = "com.kewb.valheimmjolnir.epoch";

		public const string WorldUidKey = "com.kewb.valheimmjolnir.world_uid";

		public const string SchemaKey = "com.kewb.valheimmjolnir.schema";

		public const string ProvisionalKey = "com.kewb.valheimmjolnir.provisional";

		public const string OwnerKey = "com.kewb.valheimmjolnir.owner";

		public const string QuarantineKey = "com.kewb.valheimmjolnir.quarantine";

		public const string UndiscoveredKey = "com.kewb.valheimmjolnir.undiscovered";

		public const string HammerOwnerKey = "com.kewb.valheimmjolnir.hammer_owner";

		public const string BorrowerKey = "com.kewb.valheimmjolnir.borrower";

		public const string LegacyStateKey = "com.kewb.valheimmjolnir.state";
	}
	public enum InventoryTokenTransferAction
	{
		UseVanilla,
		PreserveReference
	}
	public static class InventoryTokenTransferPolicy
	{
		public static InventoryTokenTransferAction PlanUnpositioned(bool sameInventory, bool sourceStored, int sourceStack, bool hasFreeSlot)
		{
			if (!(sameInventory && sourceStored && sourceStack == 1 && hasFreeSlot))
			{
				return InventoryTokenTransferAction.UseVanilla;
			}
			return InventoryTokenTransferAction.PreserveReference;
		}

		public static InventoryTokenTransferAction PlanPositioned(bool sameInventory, int sourceStack, int requestedAmount, int x, int y, int width, int height, bool destinationEmpty)
		{
			if (!(sameInventory && sourceStack == 1 && requestedAmount == sourceStack && x >= 0 && y >= 0 && x < width && y < height && destinationEmpty))
			{
				return InventoryTokenTransferAction.UseVanilla;
			}
			return InventoryTokenTransferAction.PreserveReference;
		}

		public static bool RetainsAllCustomData(IReadOnlyDictionary<string, string> source, IReadOnlyDictionary<string, string> destination)
		{
			foreach (KeyValuePair<string, string> item in source)
			{
				if (!destination.TryGetValue(item.Key, out string value) || value != item.Value)
				{
					return false;
				}
			}
			return true;
		}
	}
}
namespace ValheimMjolnir.Core.Gameplay
{
	public static class AbilityConflictRules
	{
		public static bool CanStart(string? requestedAbility, MjolnirAbilityState activeState, MjolnirHammerState hammerState)
		{
			switch (requestedAbility)
			{
			case "mjolnir.throw":
				return activeState == MjolnirAbilityState.Idle && hammerState == MjolnirHammerState.Held;
			case "mjolnir.guard":
				return activeState == MjolnirAbilityState.Idle && hammerState == MjolnirHammerState.Held;
			case "mjolnir.lightning":
				return activeState == MjolnirAbilityState.Idle && IsLightningReachable(hammerState);
			case "mjolnir.flight":
				return activeState == MjolnirAbilityState.Idle && hammerState == MjolnirHammerState.Held;
			case "mjolnir.lightningstep":
			{
				bool flag = ((activeState == MjolnirAbilityState.Idle || activeState == MjolnirAbilityState.Flight) ? true : false);
				return flag && hammerState == MjolnirHammerState.Held;
			}
			case "mjolnir.groundslam":
				return activeState == MjolnirAbilityState.Flight && hammerState == MjolnirHammerState.Held;
			case "mjolnir.momentumslam":
			{
				bool flag = ((activeState == MjolnirAbilityState.Idle || activeState == MjolnirAbilityState.Flight) ? true : false);
				return flag && hammerState == MjolnirHammerState.Held;
			}
			case "mjolnir.heavenfall":
			case "mjolnir.thunderspear":
			case "mjolnir.flightcharge":
				return activeState == MjolnirAbilityState.Flight && hammerState == MjolnirHammerState.Held;
			case "mjolnir.crosshaircontrol":
				return activeState == MjolnirAbilityState.Idle && IsHammerInWorld(hammerState);
			case "mjolnir.summon":
			{
				bool flag = activeState == MjolnirAbilityState.Idle;
				if (flag)
				{
					bool flag2 = ((hammerState == MjolnirHammerState.Stored || hammerState == MjolnirHammerState.Dropped || hammerState == MjolnirHammerState.Unavailable) ? true : false);
					flag = flag2;
				}
				return flag;
			}
			case "mjolnir.stormline":
			case "mjolnir.assistedleap":
			case "mjolnir.thunderclap":
			case "mjolnir.lightningpillar":
				return activeState == MjolnirAbilityState.Idle && hammerState == MjolnirHammerState.Held;
			case "mjolnir.overheadslam":
				return activeState == MjolnirAbilityState.Idle && hammerState == MjolnirHammerState.Held;
			case "mjolnir.assault":
			case "mjolnir.cyclone":
			case "mjolnir.multianglebarrage":
			{
				bool flag = activeState == MjolnirAbilityState.Idle;
				if (flag)
				{
					bool flag2 = (((uint)(hammerState - 4) <= 2u || (uint)(hammerState - 9) <= 1u) ? true : false);
					flag = flag2;
				}
				return flag;
			}
			case "mjolnir.orbitinghammer":
				return activeState == MjolnirAbilityState.Idle && hammerState == MjolnirHammerState.Returning;
			case "mjolnir.chainlightning":
				return activeState == MjolnirAbilityState.Idle && IsHammerInWorld(hammerState);
			case "mjolnir.groundedlightningrod":
			{
				bool flag = activeState == MjolnirAbilityState.Idle;
				if (flag)
				{
					bool flag2 = (((uint)(hammerState - 4) <= 2u || hammerState == MjolnirHammerState.Levitating) ? true : false);
					flag = flag2;
				}
				return flag;
			}
			case "mjolnir.godofthunder":
			case "mjolnir.summonstorm":
				return activeState == MjolnirAbilityState.Idle && hammerState == MjolnirHammerState.Held;
			case "mjolnir.godblast":
				return activeState == MjolnirAbilityState.Idle && hammerState == MjolnirHammerState.Held;
			default:
				return false;
			}
		}

		public static bool HasRule(string? abilityId)
		{
			if (abilityId != null)
			{
				if (!CanStart(abilityId, MjolnirAbilityState.Idle, MjolnirHammerState.Held) && !CanStart(abilityId, MjolnirAbilityState.Idle, MjolnirHammerState.Outbound) && !CanStart(abilityId, MjolnirAbilityState.Idle, MjolnirHammerState.Returning) && !CanStart(abilityId, MjolnirAbilityState.Idle, MjolnirHammerState.Stored) && !CanStart(abilityId, MjolnirAbilityState.Idle, MjolnirHammerState.Unavailable))
				{
					return CanStart(abilityId, MjolnirAbilityState.Flight, MjolnirHammerState.Held);
				}
				return true;
			}
			return false;
		}

		public static bool IsHammerInWorld(MjolnirHammerState hammerState)
		{
			switch (hammerState)
			{
			case MjolnirHammerState.Outbound:
			case MjolnirHammerState.Embedded:
			case MjolnirHammerState.Dropped:
			case MjolnirHammerState.Returning:
			case MjolnirHammerState.CrosshairControlled:
			case MjolnirHammerState.Levitating:
			case MjolnirHammerState.Planted:
			case MjolnirHammerState.Orbiting:
			case MjolnirHammerState.EmbeddedInEnemy:
				return true;
			default:
				return false;
			}
		}

		public static bool IsLightningReachable(MjolnirHammerState hammerState)
		{
			if (hammerState != MjolnirHammerState.Held)
			{
				return IsHammerInWorld(hammerState);
			}
			return true;
		}
	}
	public static class AbilityMath
	{
		public static float CrosshairControlSpeed(float distance, float minimumSpeed, float maximumSpeed, float range)
		{
			float num = Clamp01(distance / Math.Max(0.01f, range));
			return minimumSpeed + (maximumSpeed - minimumSpeed) * (num * num * (3f - 2f * num));
		}

		public