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

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("StoryKit.Core")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.1.12.0")]
[assembly: AssemblyInformationalVersion("0.1.12+de8ede7c1cc4e525b56eb73ca1c0bdd9555d1cc3")]
[assembly: AssemblyProduct("StoryKit.Core")]
[assembly: AssemblyTitle("StoryKit.Core")]
[assembly: AssemblyMetadata("BuildStamp", "de8ede7c 2026-09-05")]
[assembly: AssemblyVersion("0.0.0.0")]
[module: RefSafetyRules(11)]
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;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace StoryKit.Core
{
	public enum BusyLeg
	{
		None,
		Tree,
		Roster,
		ShopLocal,
		ShopRemote
	}
	public static class BusyLegNames
	{
		public static string Of(BusyLeg leg)
		{
			return leg switch
			{
				BusyLeg.Tree => "tree (NPCInteraction.ExtTree.isRunning)", 
				BusyLeg.Roster => "roster (NPCInteraction.m_npcInConversation)", 
				BusyLeg.ShopLocal => "shop (Merchant.Buyer + the local Shop panel is up)", 
				BusyLeg.ShopRemote => "shop (Merchant.Buyer is a remote shopper, inside the trust window)", 
				_ => "none", 
			};
		}
	}
	public static class ShopBusyRules
	{
		public static BusyLeg Judge(bool hasBuyer, bool buyerIsLocal, bool localPanelUp, bool transactionPending, float ageSeconds, float localGraceSeconds, float remoteGraceSeconds)
		{
			if (transactionPending)
			{
				if (!buyerIsLocal)
				{
					return BusyLeg.ShopRemote;
				}
				return BusyLeg.ShopLocal;
			}
			if (!hasBuyer)
			{
				return BusyLeg.None;
			}
			if (!buyerIsLocal)
			{
				if (!(ageSeconds <= remoteGraceSeconds))
				{
					return BusyLeg.None;
				}
				return BusyLeg.ShopRemote;
			}
			if (ageSeconds <= localGraceSeconds)
			{
				return BusyLeg.ShopLocal;
			}
			if (!localPanelUp)
			{
				return BusyLeg.None;
			}
			return BusyLeg.ShopLocal;
		}
	}
	public enum DespawnBusyVerdict
	{
		NotLive,
		RefuseBusy,
		Proceed
	}
	public static class DespawnBusyRules
	{
		public static DespawnBusyVerdict Judge(bool live, bool inDialogue, bool evenIfBusy)
		{
			if (!live)
			{
				return DespawnBusyVerdict.NotLive;
			}
			if (inDialogue && !evenIfBusy)
			{
				return DespawnBusyVerdict.RefuseBusy;
			}
			return DespawnBusyVerdict.Proceed;
		}

		public static string RefusalLine(string op, string id)
		{
			return RefusalLine(op, id, BusyLeg.None);
		}

		public static string RefusalLine(string op, string id, BusyLeg leg)
		{
			string text = ((leg == BusyLeg.None) ? "" : (" [busy leg: " + BusyLegNames.Of(leg) + "]"));
			return "[STORYKIT] " + op + "('" + id + "') REFUSED — in dialogue/trading" + text + "; destroying a Character under a running DialogueTree is the merchant-greet bug. Retry later: the guard re-evaluates fresh on every call. (Known gap: a guest's conversation with a spec that has no ActorLocKey — DR-minted on a guest — reads not-busy here, AO4-1.)";
		}
	}
	public enum DespawnVerdict
	{
		Clean,
		ForceClean,
		ReplacedByNewBody
	}
	public static class DespawnRules
	{
		public const float VerifyDelaySeconds = 0.3f;

		public static DespawnVerdict Judge(bool stillRegistered, bool sameObject)
		{
			if (!stillRegistered)
			{
				return DespawnVerdict.Clean;
			}
			if (!sameObject)
			{
				return DespawnVerdict.ReplacedByNewBody;
			}
			return DespawnVerdict.ForceClean;
		}
	}
	public static class DialogueHold
	{
		public const float MinPlanarDistance = 0.05f;

		public static bool ShouldHold(bool holdStillEnabled, bool conversationActive)
		{
			return holdStillEnabled && conversationActive;
		}

		public static bool TryFaceYaw(float npcX, float npcZ, float targetX, float targetZ, out float yawDegrees)
		{
			yawDegrees = 0f;
			float num = targetX - npcX;
			float num2 = targetZ - npcZ;
			if (num * num + num2 * num2 < 0.0025000002f)
			{
				return false;
			}
			float num3 = (float)(Math.Atan2(num, num2) * (180.0 / Math.PI));
			if (num3 < 0f)
			{
				num3 += 360f;
			}
			yawDegrees = num3;
			return true;
		}

		public static float ShortestTurn(float currentYaw, float targetYaw)
		{
			float num = (targetYaw - currentYaw) % 360f;
			if (num < -180f)
			{
				num += 360f;
			}
			else if (num > 180f)
			{
				num -= 360f;
			}
			return num;
		}
	}
	public static class DialogueLockRules
	{
		public static string KeyFor(string specId)
		{
			if (string.IsNullOrEmpty(specId))
			{
				return "";
			}
			return specId.Trim();
		}

		public static bool CanLock(string actorLocKey)
		{
			return !string.IsNullOrEmpty(actorLocKey);
		}

		public static bool NeedsLocEntry(string actorLocKey, string displayName, bool tableAlreadyHasKey)
		{
			if (!CanLock(actorLocKey))
			{
				return false;
			}
			if (tableAlreadyHasKey)
			{
				return false;
			}
			return !string.IsNullOrEmpty(displayName);
		}
	}
	public static class DialogueWire
	{
		public const string ChannelId = "story";

		public const string ChannelVersion = "0.1.0";

		public const string VerbRevision = "story.dlg";

		public const string VerbRevisionClear = "story.dlg.clear";

		public const string VerbInvoke = "story.act";

		internal const char Sep = '\t';

		public static bool IsFieldSafe(string s)
		{
			if (s != null && s.IndexOf('\t') < 0 && s.IndexOf('\n') < 0)
			{
				return s.IndexOf('\r') < 0;
			}
			return false;
		}
	}
	public struct RevisionStamp : IEquatable<RevisionStamp>
	{
		public readonly string Epoch;

		public readonly int Revision;

		public RevisionStamp(string epoch, int revision)
		{
			Epoch = epoch ?? "";
			Revision = revision;
		}

		public bool Equals(RevisionStamp other)
		{
			if (string.Equals(Epoch, other.Epoch, StringComparison.Ordinal))
			{
				return Revision == other.Revision;
			}
			return false;
		}

		public override bool Equals(object obj)
		{
			if (obj is RevisionStamp)
			{
				return Equals((RevisionStamp)obj);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return ((Epoch ?? "").GetHashCode() * 397) ^ Revision;
		}

		public override string ToString()
		{
			string epoch = Epoch;
			int revision = Revision;
			return epoch + "#" + revision;
		}
	}
	public enum RevisionObservation
	{
		First,
		Same,
		Newer,
		Stale,
		NewEpoch
	}
	public sealed class RevisionBook
	{
		private readonly Dictionary<string, RevisionStamp> _known = new Dictionary<string, RevisionStamp>(StringComparer.Ordinal);

		public int Count => _known.Count;

		public RevisionObservation Observe(string specId, RevisionStamp stamp)
		{
			if (specId == null)
			{
				specId = "";
			}
			if (!_known.TryGetValue(specId, out var value))
			{
				_known[specId] = stamp;
				return RevisionObservation.First;
			}
			if (!string.Equals(value.Epoch, stamp.Epoch, StringComparison.Ordinal))
			{
				_known[specId] = stamp;
				return RevisionObservation.NewEpoch;
			}
			if (stamp.Revision == value.Revision)
			{
				return RevisionObservation.Same;
			}
			if (stamp.Revision < value.Revision)
			{
				return RevisionObservation.Stale;
			}
			_known[specId] = stamp;
			return RevisionObservation.Newer;
		}

		public bool TryGetKnown(string specId, out RevisionStamp stamp)
		{
			return _known.TryGetValue(specId ?? "", out stamp);
		}

		public bool Forget(string specId)
		{
			return _known.Remove(specId ?? "");
		}

		public void Clear()
		{
			_known.Clear();
		}
	}
	public static class RevisionCodec
	{
		public static string Encode(RevisionStamp stamp, string menuHint)
		{
			menuHint = menuHint ?? "";
			if (stamp.Revision < 1)
			{
				return null;
			}
			if (string.IsNullOrEmpty(stamp.Epoch))
			{
				return null;
			}
			if (!DialogueWire.IsFieldSafe(stamp.Epoch) || !DialogueWire.IsFieldSafe(menuHint))
			{
				return null;
			}
			string[] obj = new string[5] { stamp.Epoch, "\t", null, null, null };
			int revision = stamp.Revision;
			obj[2] = revision.ToString();
			obj[3] = "\t";
			obj[4] = menuHint;
			return string.Concat(obj);
		}

		public static bool TryParse(string payload, out RevisionStamp stamp, out string menuHint)
		{
			stamp = default(RevisionStamp);
			menuHint = "";
			if (string.IsNullOrEmpty(payload))
			{
				return false;
			}
			string[] array = payload.Split(new char[1] { '\t' });
			if (array.Length != 3)
			{
				return false;
			}
			if (string.IsNullOrEmpty(array[0]))
			{
				return false;
			}
			if (!int.TryParse(array[1], out var result) || result < 1)
			{
				return false;
			}
			stamp = new RevisionStamp(array[0], result);
			menuHint = array[2];
			return true;
		}
	}
	public static class InvokeCodec
	{
		private const string Ok = "ok";

		private const string Refused = "refused";

		public static string EncodeRequest(string specId, string actionId, RevisionStamp knownRev, string instigatorUid)
		{
			instigatorUid = instigatorUid ?? "";
			string text = knownRev.Epoch ?? "";
			if (string.IsNullOrEmpty(specId) || string.IsNullOrEmpty(actionId))
			{
				return null;
			}
			if (!DialogueWire.IsFieldSafe(specId) || !DialogueWire.IsFieldSafe(actionId) || !DialogueWire.IsFieldSafe(text) || !DialogueWire.IsFieldSafe(instigatorUid))
			{
				return null;
			}
			if (knownRev.Revision < 0)
			{
				return null;
			}
			string[] obj = new string[9] { specId, "\t", actionId, "\t", text, "\t", null, null, null };
			int revision = knownRev.Revision;
			obj[6] = revision.ToString();
			obj[7] = "\t";
			obj[8] = instigatorUid;
			return string.Concat(obj);
		}

		public static bool TryParseRequest(string body, out string specId, out string actionId, out RevisionStamp knownRev, out string instigatorUid)
		{
			specId = (actionId = (instigatorUid = ""));
			knownRev = default(RevisionStamp);
			if (string.IsNullOrEmpty(body))
			{
				return false;
			}
			string[] array = body.Split(new char[1] { '\t' });
			if (array.Length != 5)
			{
				return false;
			}
			if (string.IsNullOrEmpty(array[0]) || string.IsNullOrEmpty(array[1]))
			{
				return false;
			}
			if (!int.TryParse(array[3], out var result) || result < 0)
			{
				return false;
			}
			specId = array[0];
			actionId = array[1];
			knownRev = new RevisionStamp(array[2], result);
			instigatorUid = array[4];
			return true;
		}

		public static string EncodeOk(string detail = "")
		{
			detail = detail ?? "";
			if (!DialogueWire.IsFieldSafe(detail))
			{
				return null;
			}
			if (detail.Length != 0)
			{
				return "ok\t" + detail;
			}
			return "ok";
		}

		public static string EncodeRefusal(string reason, string detail = "")
		{
			detail = detail ?? "";
			if (string.IsNullOrEmpty(reason))
			{
				return null;
			}
			if (!DialogueWire.IsFieldSafe(reason) || !DialogueWire.IsFieldSafe(detail))
			{
				return null;
			}
			if (detail.Length != 0)
			{
				return "refused\t" + reason + "\t" + detail;
			}
			return "refused\t" + reason;
		}

		public static bool ParseResult(string result, out string refusalReason, out string detail)
		{
			refusalReason = "";
			detail = "";
			if (string.IsNullOrEmpty(result))
			{
				refusalReason = "malformed";
				return false;
			}
			string[] array = result.Split(new char[1] { '\t' });
			if (array[0] == "ok" && array.Length <= 2)
			{
				if (array.Length == 2)
				{
					detail = array[1];
				}
				return true;
			}
			if (array[0] == "refused" && (array.Length == 2 || array.Length == 3) && array[1].Length != 0)
			{
				refusalReason = array[1];
				if (array.Length == 3)
				{
					detail = array[2];
				}
				return false;
			}
			refusalReason = "malformed";
			return false;
		}
	}
	public static class InvokeRefusal
	{
		public const string NoSpec = "no-spec";

		public const string NoHandler = "no-handler";

		public const string StaleRevision = "stale-rev";

		public const string NoInstigator = "no-instigator";

		public const string NotMaster = "not-master";

		public const string HandlerRefused = "handler-refused";

		public const string HandlerThrew = "handler-threw";

		public const string Malformed = "malformed";

		public static bool ShouldRerender(string reason)
		{
			if (!(reason == "stale-rev"))
			{
				return reason == "no-spec";
			}
			return true;
		}

		public static string Describe(string reason)
		{
			return reason switch
			{
				"no-spec" => "the master no longer has this NPC", 
				"no-handler" => "the master has no handler for this choice", 
				"stale-rev" => "this menu is out of date — reopening", 
				"no-instigator" => "the master could not resolve who picked this", 
				"not-master" => "the session master changed mid-request", 
				"handler-refused" => "the master declined this choice", 
				"handler-threw" => "the master failed running this choice", 
				"malformed" => "the answer could not be read", 
				_ => "refused (" + reason + ")", 
			};
		}
	}
	public static class JsonText
	{
		public static string Quote(string s)
		{
			if (s == null)
			{
				return "\"\"";
			}
			StringBuilder stringBuilder = new StringBuilder(s.Length + 2);
			stringBuilder.Append('"');
			foreach (char c in s)
			{
				if (c == '"' || c == '\\')
				{
					stringBuilder.Append('\\').Append(c);
				}
				else if (c == '\n')
				{
					stringBuilder.Append("\\n");
				}
				else if (c == '\r')
				{
					stringBuilder.Append("\\r");
				}
				else if (c == '\t')
				{
					stringBuilder.Append("\\t");
				}
				else if (c == '\b')
				{
					stringBuilder.Append("\\b");
				}
				else if (c == '\f')
				{
					stringBuilder.Append("\\f");
				}
				else if (c < ' ')
				{
					StringBuilder stringBuilder2 = stringBuilder.Append("\\u");
					int num = c;
					stringBuilder2.Append(num.ToString("x4"));
				}
				else
				{
					stringBuilder.Append(c);
				}
			}
			return stringBuilder.Append('"').ToString();
		}
	}
	public enum MenuNodeKind
	{
		Greet,
		Train,
		Menu,
		Reply,
		Shop,
		Action
	}
	public struct MenuNodeRef : IEquatable<MenuNodeRef>
	{
		public readonly MenuNodeKind Kind;

		public readonly int Id;

		public static readonly MenuNodeRef Greet = new MenuNodeRef(MenuNodeKind.Greet, -1);

		public static readonly MenuNodeRef Train = new MenuNodeRef(MenuNodeKind.Train, -1);

		public static readonly MenuNodeRef Shop = new MenuNodeRef(MenuNodeKind.Shop, -1);

		public MenuNodeRef(MenuNodeKind kind, int id)
		{
			Kind = kind;
			Id = id;
		}

		public bool Equals(MenuNodeRef other)
		{
			if (Kind == other.Kind)
			{
				return Id == other.Id;
			}
			return false;
		}

		public override bool Equals(object obj)
		{
			if (obj is MenuNodeRef)
			{
				return Equals((MenuNodeRef)obj);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return ((int)Kind * 397) ^ Id;
		}

		public override string ToString()
		{
			if (Id < 0)
			{
				return Kind.ToString();
			}
			string text = Kind.ToString();
			int id = Id;
			return text + "#" + id;
		}
	}
	public sealed class MenuNode
	{
		public MenuNodeKind Kind;

		public int Id;

		public int Depth;

		public string ChoiceId;

		public List<string> Labels = new List<string>();

		public int BackIndex = -1;

		public string ReplyText;

		public string ActionId;

		public MenuNodeRef Ref => new MenuNodeRef(Kind, Id);
	}
	public sealed class MenuEdge
	{
		public MenuNodeRef Source;

		public int SourceIndex;

		public MenuNodeRef Target;

		public string Label;

		public override string ToString()
		{
			string[] array = new string[8];
			MenuNodeRef source = Source;
			array[0] = source.ToString();
			array[1] = "[";
			array[2] = SourceIndex.ToString();
			array[3] = "] -> ";
			source = Target;
			array[4] = source.ToString();
			array[5] = " '";
			array[6] = Label;
			array[7] = "'";
			return string.Concat(array);
		}
	}
	public enum MenuDropReason
	{
		NullRow,
		TrainNoTrainer,
		TrainInSubmenu,
		TrainNoNode,
		ShopNoMerchant,
		ShopInSubmenu,
		ActionNoHandler
	}
	public sealed class MenuDrop
	{
		public MenuDropReason Reason;

		public int Depth;

		public int Index;

		public string ChoiceId;

		public override string ToString()
		{
			return Reason.ToString() + " depth=" + Depth + " #" + Index + ((ChoiceId != null) ? (" '" + ChoiceId + "'") : "");
		}
	}
	public sealed class MenuPlan
	{
		public List<MenuNode> Nodes = new List<MenuNode>();

		public List<MenuEdge> Edges = new List<MenuEdge>();

		public MenuNodeRef Root;

		public string Outline = "";

		public int NullRowsSkipped;

		public List<MenuDrop> Drops = new List<MenuDrop>();

		public int VisibleRowCount(MenuNodeRef r)
		{
			MenuNode menuNode = Node(r);
			if (menuNode == null)
			{
				return 0;
			}
			return menuNode.Labels.Count - ((menuNode.BackIndex >= 0) ? 1 : 0);
		}

		public MenuNode Node(MenuNodeRef r)
		{
			if (r.Id < 0)
			{
				return null;
			}
			return Nodes[r.Id];
		}
	}
	public static class MenuPlanner
	{
		private sealed class PlanFlags
		{
			public bool WantsTrain;

			public bool TrainNodeAvailable;

			public bool WantsShop;

			public Func<string, bool> HandlerAvailable;
		}

		public static MenuPlan Plan(IList<Choice> rows, bool wantsTrain, bool trainNodeAvailable, string rootBackText = null)
		{
			return Plan(rows, wantsTrain, trainNodeAvailable, rootBackText, wantsShop: false, shopNodeAvailable: false);
		}

		public static MenuPlan Plan(IList<Choice> rows, bool wantsTrain, bool trainNodeAvailable, string rootBackText, bool wantsShop, bool shopNodeAvailable)
		{
			return Plan(rows, wantsTrain, trainNodeAvailable, rootBackText, wantsShop, shopNodeAvailable, null);
		}

		public static MenuPlan Plan(IList<Choice> rows, bool wantsTrain, bool trainNodeAvailable, string rootBackText, bool wantsShop, bool shopNodeAvailable, Func<string, bool> handlerAvailable)
		{
			MenuPlan menuPlan = new MenuPlan();
			StringBuilder stringBuilder = new StringBuilder();
			PlanFlags flags = new PlanFlags
			{
				WantsTrain = wantsTrain,
				TrainNodeAvailable = trainNodeAvailable,
				WantsShop = (wantsShop && shopNodeAvailable),
				HandlerAvailable = handlerAvailable
			};
			menuPlan.Root = PlanMenu(menuPlan, stringBuilder, flags, rows, MenuNodeRef.Greet, rootBackText, 0);
			menuPlan.Outline = stringBuilder.ToString();
			return menuPlan;
		}

		private static MenuNodeRef PlanMenu(MenuPlan plan, StringBuilder outline, PlanFlags flags, IList<Choice> rows, MenuNodeRef returnTarget, string backText, int depth)
		{
			if (depth > 4)
			{
				throw new InvalidOperationException("submenu nesting exceeded MaxMenuDepth (" + 3 + ") at depth " + depth + " — a validation bypass or a cycle in the Choice graph.");
			}
			List<Choice> list = new List<Choice>();
			if (rows != null)
			{
				for (int i = 0; i < rows.Count; i++)
				{
					Choice choice = rows[i];
					if (choice == null)
					{
						plan.NullRowsSkipped++;
						plan.Drops.Add(new MenuDrop
						{
							Reason = MenuDropReason.NullRow,
							Depth = depth,
							Index = i
						});
					}
					else if (choice.Kind == ChoiceKind.Train && (!flags.WantsTrain || depth > 0 || !flags.TrainNodeAvailable))
					{
						plan.Drops.Add(new MenuDrop
						{
							Reason = ((depth > 0) ? MenuDropReason.TrainInSubmenu : ((!flags.WantsTrain) ? MenuDropReason.TrainNoTrainer : MenuDropReason.TrainNoNode)),
							Depth = depth,
							Index = i,
							ChoiceId = choice.Id
						});
					}
					else if (choice.Kind == ChoiceKind.Shop && (!flags.WantsShop || depth > 0))
					{
						plan.Drops.Add(new MenuDrop
						{
							Reason = ((depth > 0) ? MenuDropReason.ShopInSubmenu : MenuDropReason.ShopNoMerchant),
							Depth = depth,
							Index = i,
							ChoiceId = choice.Id
						});
					}
					else if (choice.Kind == ChoiceKind.Action && (string.IsNullOrEmpty(choice.ActionId) || flags.HandlerAvailable == null || !flags.HandlerAvailable(choice.ActionId)))
					{
						plan.Drops.Add(new MenuDrop
						{
							Reason = MenuDropReason.ActionNoHandler,
							Depth = depth,
							Index = i,
							ChoiceId = choice.Id
						});
					}
					else
					{
						list.Add(choice);
					}
				}
			}
			MenuNode menuNode = new MenuNode
			{
				Kind = MenuNodeKind.Menu,
				Id = plan.Nodes.Count,
				Depth = depth
			};
			plan.Nodes.Add(menuNode);
			string text = new string(' ', 2 + depth * 2);
			for (int j = 0; j < list.Count; j++)
			{
				Choice choice2 = list[j];
				menuNode.Labels.Add(choice2.Text);
				outline.Append("\n" + text + j + ". '" + Trim(choice2.Text) + "' → " + choice2.Kind);
				if (choice2.Kind == ChoiceKind.Train)
				{
					plan.Edges.Add(new MenuEdge
					{
						Source = menuNode.Ref,
						SourceIndex = j,
						Target = MenuNodeRef.Train,
						Label = choice2.Id
					});
					continue;
				}
				if (choice2.Kind == ChoiceKind.Shop)
				{
					plan.Edges.Add(new MenuEdge
					{
						Source = menuNode.Ref,
						SourceIndex = j,
						Target = MenuNodeRef.Shop,
						Label = choice2.Id
					});
					continue;
				}
				if (choice2.Kind == ChoiceKind.Menu)
				{
					MenuNodeRef target = PlanMenu(plan, outline, flags, choice2.Children, menuNode.Ref, choice2.BackText ?? "← Back", depth + 1);
					plan.Edges.Add(new MenuEdge
					{
						Source = menuNode.Ref,
						SourceIndex = j,
						Target = target,
						Label = choice2.Id
					});
					continue;
				}
				MenuNodeRef source = menuNode.Ref;
				int sourceIndex = j;
				if (choice2.Kind == ChoiceKind.Action)
				{
					MenuNode menuNode2 = new MenuNode
					{
						Kind = MenuNodeKind.Action,
						Id = plan.Nodes.Count,
						Depth = depth,
						ChoiceId = choice2.Id,
						ActionId = choice2.ActionId
					};
					plan.Nodes.Add(menuNode2);
					plan.Edges.Add(new MenuEdge
					{
						Source = menuNode.Ref,
						SourceIndex = j,
						Target = menuNode2.Ref,
						Label = choice2.Id
					});
					source = menuNode2.Ref;
					sourceIndex = -1;
				}
				MenuNode menuNode3 = new MenuNode
				{
					Kind = MenuNodeKind.Reply,
					Id = plan.Nodes.Count,
					Depth = depth,
					ChoiceId = choice2.Id,
					ReplyText = (choice2.ReplyText ?? "...")
				};
				plan.Nodes.Add(menuNode3);
				plan.Edges.Add(new MenuEdge
				{
					Source = source,
					SourceIndex = sourceIndex,
					Target = menuNode3.Ref,
					Label = choice2.Id
				});
				plan.Edges.Add(new MenuEdge
				{
					Source = menuNode3.Ref,
					Target = ((depth == 0) ? MenuNodeRef.Greet : menuNode.Ref),
					SourceIndex = -1,
					Label = choice2.Id + ":return"
				});
			}
			if (backText != null)
			{
				menuNode.BackIndex = list.Count;
				menuNode.Labels.Add(backText);
				plan.Edges.Add(new MenuEdge
				{
					Source = menuNode.Ref,
					Target = returnTarget,
					SourceIndex = list.Count,
					Label = "<back>"
				});
				outline.Append("\n" + text + list.Count + ". '" + Trim(backText) + "' → Back");
			}
			return menuNode.Ref;
		}

		internal static string Trim(string s)
		{
			if (s == null || s.Length <= 30)
			{
				return s;
			}
			return s.Substring(0, 30) + "…";
		}
	}
	public static class MerchantRefreshRules
	{
		public const double Unstamped = -1.0;

		public static bool ShouldFillFallback(double nextRefreshBefore, double nextRefreshAfter, int itemCount)
		{
			if (itemCount > 0)
			{
				return false;
			}
			return nextRefreshAfter > nextRefreshBefore;
		}

		public static double StampAfterFallback(double gameTime, float specRefreshRateGameHours, double nextRefreshAfterRoll)
		{
			double num = ((specRefreshRateGameHours > 0f) ? ((double)specRefreshRateGameHours) : 0.0);
			double num2 = gameTime + num;
			if (!(nextRefreshAfterRoll > num2))
			{
				return num2;
			}
			return nextRefreshAfterRoll;
		}
	}
	public enum RoomRoleEvent
	{
		First,
		None,
		RoomChanged,
		MasterFlipped
	}
	public sealed class RoomRoleWatch
	{
		private string _room;

		private bool _isMaster;

		private bool _known;

		public string Room => _room;

		public bool IsMaster => _isMaster;

		public RoomRoleEvent Observe(string room, bool isMaster)
		{
			bool flag = _known && !string.Equals(room, _room, StringComparison.Ordinal);
			bool flag2 = _known && isMaster != _isMaster;
			bool num = !_known;
			_room = room;
			_isMaster = isMaster;
			_known = true;
			if (num)
			{
				return RoomRoleEvent.First;
			}
			if (flag)
			{
				return RoomRoleEvent.RoomChanged;
			}
			if (flag2)
			{
				return RoomRoleEvent.MasterFlipped;
			}
			return RoomRoleEvent.None;
		}
	}
	public static class OrphanSweepRules
	{
		public static bool LooksMintedSpecId(string uid)
		{
			if (string.IsNullOrEmpty(uid))
			{
				return false;
			}
			if (uid.Length >= 20)
			{
				return uid.IndexOf('.') >= 0;
			}
			return true;
		}

		public static bool ShouldSweep(bool slNamed, bool hasLocalTemplate, bool hasLocalSpec, string uid)
		{
			if (slNamed && !hasLocalTemplate && !hasLocalSpec)
			{
				return LooksMintedSpecId(uid);
			}
			return false;
		}
	}
	public sealed class NpcSpec
	{
		public const float WalkSpeed = 0.3f;

		public const float RunSpeed = 1.1f;

		public string Id;

		public string Name;

		public List<Placement> Placements = new List<Placement>();

		public TrainerSpec Trainer;

		public DialogueSpec Dialogue = new DialogueSpec();

		public int WeaponId;

		public int HelmetId;

		public int ChestId;

		public int BootsId;

		public int BackpackId;

		public int ShieldId;

		public VisualIndices Visuals;

		public bool RandomVisuals;

		public List<OutfitSpec> OutfitPool;

		public bool LookFollowEnabled = true;

		public bool HoldStillInDialogue = true;

		public bool Mobile;

		public AiSpec Ai;

		public CombatSpec Combat;

		public string BackpackName;

		public string Faction;

		public MerchantSpec Merchant;
	}
	public sealed class VisualIndices
	{
		public int Gender;

		public int SkinIndex;

		public int HeadVariationIndex;

		public int HairStyleIndex;

		public int HairColorIndex;

		public override string ToString()
		{
			return $"gender={Gender} skin={SkinIndex} head={HeadVariationIndex} hair={HairStyleIndex} hairColor={HairColorIndex}";
		}
	}
	public sealed class OutfitSpec
	{
		public string ChestName;

		public string HelmetName;

		public string BootsName;

		public string WeaponName;

		public bool IsEmpty
		{
			get
			{
				if (string.IsNullOrEmpty(ChestName) && string.IsNullOrEmpty(HelmetName) && string.IsNullOrEmpty(BootsName))
				{
					return string.IsNullOrEmpty(WeaponName);
				}
				return false;
			}
		}

		public OutfitSpec()
		{
		}

		public OutfitSpec(string chest, string helmet = null, string boots = null, string weapon = null)
		{
			ChestName = chest;
			HelmetName = helmet;
			BootsName = boots;
			WeaponName = weapon;
		}
	}
	public sealed class AiSpec
	{
		public float WanderSpeed = 0.3f;

		public bool CanWanderFar = true;

		public bool CanBlock = true;

		public bool CanDodge = true;

		public float ChanceToAttack = 75f;

		public bool Passive;
	}
	public sealed class CombatSpec
	{
		public float? Health;

		public float? Protection;

		public float[] DamageResists;

		public float DamageBonusMult = 1f;

		public List<string> TargetableFactions;
	}
	public sealed class MerchantSpec
	{
		public string StockTableNameContains;

		public List<string> FallbackItemNames;

		public float RefreshRateGameHours = 72f;

		public bool NonSavable = true;

		public bool Buyer = true;

		public bool Seller = true;
	}
	public sealed class Placement
	{
		public string Scene;

		public float X;

		public float Y;

		public float Z;

		public float RotationY;

		public Placement()
		{
		}

		public Placement(string scene, float x, float y, float z, float rotY = 0f)
		{
			Scene = scene;
			X = x;
			Y = y;
			Z = z;
			RotationY = rotY;
		}
	}
	public sealed class TrainerSpec
	{
		public string SkillTreeUID;

		public SkillTreeDef Tree;
	}
	public sealed class DialogueSpec
	{
		public List<string> Greetings = new List<string>();

		public List<Choice> Choices = new List<Choice>();
	}
	public enum ChoiceKind
	{
		Train,
		Reply,
		Menu,
		Shop,
		Action
	}
	public sealed class Choice
	{
		public string Id;

		public string Text;

		public ChoiceKind Kind;

		public string ReplyText;

		public string ActionId;

		public List<Choice> Children;

		public string BackText = "← Back";

		public static Choice Train(string id, string text)
		{
			return new Choice
			{
				Id = id,
				Text = text,
				Kind = ChoiceKind.Train
			};
		}

		public static Choice Reply(string id, string text, string replyText)
		{
			return new Choice
			{
				Id = id,
				Text = text,
				Kind = ChoiceKind.Reply,
				ReplyText = replyText
			};
		}

		public static Choice Action(string id, string text, string replyText, string actionId)
		{
			return new Choice
			{
				Id = id,
				Text = text,
				Kind = ChoiceKind.Action,
				ReplyText = replyText,
				ActionId = actionId
			};
		}

		public static Choice Shop(string id, string text)
		{
			return new Choice
			{
				Id = id,
				Text = text,
				Kind = ChoiceKind.Shop
			};
		}

		public static Choice Menu(string id, string text, params Choice[] children)
		{
			return new Choice
			{
				Id = id,
				Text = text,
				Kind = ChoiceKind.Menu,
				Children = new List<Choice>(children ?? new Choice[0])
			};
		}
	}
	public sealed class SkillTreeDef
	{
		public string Name;

		public List<SlotDef> Slots = new List<SlotDef>();
	}
	public sealed class SlotDef
	{
		public int Row;

		public int Column;

		public int SkillId;

		public int SilverCost;

		public int RequiredRow;

		public int RequiredColumn;

		public bool Breakthrough;

		public SlotDef()
		{
		}

		public SlotDef(int row, int col, int skillId, int silverCost, int requiredRow = 0, int requiredColumn = 0, bool breakthrough = false)
		{
			Row = row;
			Column = col;
			SkillId = skillId;
			SilverCost = silverCost;
			RequiredRow = requiredRow;
			RequiredColumn = requiredColumn;
			Breakthrough = breakthrough;
		}
	}
	public static class OutfitRoll
	{
		public static OutfitSpec Pick(IList<OutfitSpec> pool, double roll01)
		{
			if (pool == null || pool.Count == 0)
			{
				return null;
			}
			if (roll01 < 0.0)
			{
				roll01 = 0.0;
			}
			if (roll01 > 1.0)
			{
				roll01 = 1.0;
			}
			int num = (int)(roll01 * (double)pool.Count);
			if (num >= pool.Count)
			{
				num = pool.Count - 1;
			}
			return pool[num];
		}
	}
	public static class QuestEventRules
	{
		public const string ReconUidPrefix = "bw.srecon.";

		public static bool IsPresent(int stack)
		{
			return stack > 0;
		}

		public static bool IsStored(int stack)
		{
			return stack >= 0;
		}

		public static string LivenessLabel(int stack)
		{
			if (stack >= 0)
			{
				if (stack <= 0)
				{
					return "DORMANT";
				}
				return "ACTIVE";
			}
			return null;
		}

		public static bool IsReconSaveRow(string identifier)
		{
			return identifier?.StartsWith("bw.srecon.", StringComparison.Ordinal) ?? false;
		}
	}
	public enum RegistryOp
	{
		SpawnAt,
		Despawn,
		Unregister,
		Respawn,
		Rebuild,
		ReplaceGreetings
	}
	public static class RegistryAuthority
	{
		public static bool Allowed(RegistryOp op, bool isNonMasterClient)
		{
			return !isNonMasterClient;
		}

		public static string Refusal(RegistryOp op, string id)
		{
			return $"[STORYKIT] {op}('{id}') REFUSED — non-master client; the master owns the NPC lifecycle (a guest call here would delete or fork the NPC for every peer).";
		}
	}
	public enum FailureVerdict
	{
		Report,
		Quiet,
		Capped
	}
	public sealed class RigFailurePolicy
	{
		public const int DefaultMaxAttempts = 5;

		private readonly Dictionary<string, int> _failures = new Dictionary<string, int>();

		public int MaxAttempts { get; }

		public IEnumerable<string> CappedIds
		{
			get
			{
				foreach (KeyValuePair<string, int> failure in _failures)
				{
					if (failure.Value >= MaxAttempts)
					{
						yield return failure.Key;
					}
				}
			}
		}

		public RigFailurePolicy()
			: this(5)
		{
		}

		public RigFailurePolicy(int maxAttempts)
		{
			MaxAttempts = ((maxAttempts < 1) ? 1 : maxAttempts);
		}

		private static string Key(string id)
		{
			return id ?? string.Empty;
		}

		public int FailureCount(string id)
		{
			if (!_failures.TryGetValue(Key(id), out var value))
			{
				return 0;
			}
			return value;
		}

		public bool ShouldAttempt(string id)
		{
			return FailureCount(id) < MaxAttempts;
		}

		public void RecordSuccess(string id)
		{
			_failures.Remove(Key(id));
		}

		public FailureVerdict RecordFailure(string id)
		{
			string text = Key(id);
			int num = FailureCount(text) + 1;
			if (num > MaxAttempts)
			{
				num = MaxAttempts;
			}
			_failures[text] = num;
			if (num >= MaxAttempts)
			{
				return FailureVerdict.Capped;
			}
			if (num != 1)
			{
				return FailureVerdict.Quiet;
			}
			return FailureVerdict.Report;
		}

		public void Reset()
		{
			_failures.Clear();
		}
	}
	public readonly struct RingSlot
	{
		public readonly float AngleDeg;

		public readonly float X;

		public readonly float Z;

		public RingSlot(float angleDeg, float x, float z)
		{
			AngleDeg = angleDeg;
			X = x;
			Z = z;
		}

		public static RingSlot At(float angleDeg, float radius)
		{
			double num = (double)angleDeg * Math.PI / 180.0;
			return new RingSlot(angleDeg, (float)(Math.Sin(num) * (double)radius), (float)(Math.Cos(num) * (double)radius));
		}

		public override string ToString()
		{
			return $"{AngleDeg:F0}° ({X:F2},{Z:F2})";
		}
	}
	public static class RingPlan
	{
		public static readonly float[] AngleNudgesDeg = new float[4] { 15f, -15f, 30f, -30f };

		public static readonly float[] RadiusScales = new float[2] { 0.75f, 1.25f };

		public static IReadOnlyList<RingSlot> Slots(int count, float radius, float centreAngleDeg, float spreadDeg)
		{
			List<RingSlot> list = new List<RingSlot>(Math.Max(0, count));
			if (count <= 0)
			{
				return list;
			}
			if (count == 1)
			{
				list.Add(RingSlot.At(centreAngleDeg, radius));
				return list;
			}
			float num = spreadDeg / (float)(count - 1);
			float num2 = centreAngleDeg - spreadDeg / 2f;
			for (int i = 0; i < count; i++)
			{
				list.Add(RingSlot.At(num2 + (float)i * num, radius));
			}
			return list;
		}

		public static IReadOnlyList<RingSlot> Fallbacks(RingSlot slot, float radius)
		{
			List<RingSlot> list = new List<RingSlot>(AngleNudgesDeg.Length + RadiusScales.Length * (AngleNudgesDeg.Length + 1));
			float[] angleNudgesDeg = AngleNudgesDeg;
			foreach (float num in angleNudgesDeg)
			{
				list.Add(RingSlot.At(slot.AngleDeg + num, radius));
			}
			angleNudgesDeg = RadiusScales;
			foreach (float num2 in angleNudgesDeg)
			{
				float radius2 = radius * num2;
				list.Add(RingSlot.At(slot.AngleDeg, radius2));
				float[] angleNudgesDeg2 = AngleNudgesDeg;
				foreach (float num3 in angleNudgesDeg2)
				{
					list.Add(RingSlot.At(slot.AngleDeg + num3, radius2));
				}
			}
			return list;
		}

		public static bool Spaced(RingSlot candidate, IReadOnlyList<RingSlot> placed, float minSpacing)
		{
			if (placed == null || minSpacing <= 0f)
			{
				return true;
			}
			float num = minSpacing * minSpacing;
			for (int i = 0; i < placed.Count; i++)
			{
				float num2 = candidate.X - placed[i].X;
				float num3 = candidate.Z - placed[i].Z;
				if (num2 * num2 + num3 * num3 < num)
				{
					return false;
				}
			}
			return true;
		}
	}
	public static class SaveArtifact
	{
		private static readonly string[] Markers = new string[2] { ".bak", ".removed-for-" };

		public static bool IsBackupUid(string uid)
		{
			return MarkerIn(uid) != null;
		}

		public static string MarkerIn(string uid)
		{
			if (string.IsNullOrEmpty(uid))
			{
				return null;
			}
			string[] markers = Markers;
			foreach (string text in markers)
			{
				if (uid.IndexOf(text, StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return text;
				}
			}
			return null;
		}

		public static string OriginalUid(string uid)
		{
			string text = MarkerIn(uid);
			if (text == null)
			{
				return uid;
			}
			int num = uid.IndexOf(text, StringComparison.OrdinalIgnoreCase);
			if (num <= 0)
			{
				return uid;
			}
			return uid.Substring(0, num);
		}

		public static string ReasonFor(string uid)
		{
			string text = MarkerIn(uid);
			if (text == null)
			{
				return null;
			}
			string text2 = OriginalUid(uid);
			return "backup artifact ('" + text + "' in the save folder name)" + ((text2 != uid) ? (" — a copy of '" + text2 + "'") : "");
		}
	}
	public struct SavedItem
	{
		public string Uid;

		public int ItemId;

		public string Hierarchy;

		public int Quantity;

		public float Durability;

		public string SubClassesData;

		public string ItemExtensions;

		public override string ToString()
		{
			return $"{ItemId} x{Quantity} @'{Hierarchy}' ({Uid})";
		}
	}
	public static class SavedItemParser
	{
		public static bool TryParse(string syncDataXml, out SavedItem item)
		{
			item = default(SavedItem);
			if (string.IsNullOrEmpty(syncDataXml))
			{
				return false;
			}
			try
			{
				XmlDocument xmlDocument = new XmlDocument();
				xmlDocument.LoadXml(syncDataXml);
				XmlElement xmlElement = xmlDocument["Item"];
				if (xmlElement == null)
				{
					return false;
				}
				XmlElement xmlElement2 = xmlElement["ID"];
				if (xmlElement2 == null || !int.TryParse(xmlElement2.InnerText, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
				{
					return false;
				}
				item = new SavedItem
				{
					Uid = Text(xmlElement["UID"]),
					ItemId = result,
					Hierarchy = Text(xmlElement["Hierarchy"]),
					Quantity = 1,
					Durability = -1f,
					SubClassesData = Text(xmlElement["SubClassesData"]),
					ItemExtensions = Text(xmlElement["ItemExtensions"])
				};
				XmlElement xmlElement3 = xmlElement["Quantity"];
				if (xmlElement3 != null && int.TryParse(xmlElement3.InnerText, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2) && result2 > 0)
				{
					item.Quantity = result2;
				}
				XmlElement xmlElement4 = xmlElement["Durability"];
				if (xmlElement4 != null && float.TryParse(xmlElement4.InnerText, NumberStyles.Float, CultureInfo.InvariantCulture, out var result3))
				{
					item.Durability = result3;
				}
				return true;
			}
			catch (XmlException)
			{
				return false;
			}
		}

		private static string Text(XmlElement e)
		{
			if (e == null)
			{
				return "";
			}
			return e.InnerText ?? "";
		}

		public static string WornHierarchy(string ownerUid)
		{
			return "2" + ownerUid;
		}

		public static string PouchUid(string ownerUid)
		{
			return "Pouch_" + ownerUid;
		}

		public static string BagContentUid(string bagUid)
		{
			return bagUid + "_Content";
		}

		public static bool IsWornBy(SavedItem it, string ownerUid)
		{
			if (!string.IsNullOrEmpty(ownerUid))
			{
				return string.Equals(it.Hierarchy, WornHierarchy(ownerUid), StringComparison.Ordinal);
			}
			return false;
		}

		public static bool IsInsideContainer(SavedItem it, string containerUid)
		{
			if (!string.IsNullOrEmpty(containerUid) && it.Hierarchy != null)
			{
				return it.Hierarchy.StartsWith("1" + containerUid + ";", StringComparison.Ordinal);
			}
			return false;
		}

		public static bool IsInPouchOf(SavedItem it, string ownerUid)
		{
			if (!string.IsNullOrEmpty(ownerUid))
			{
				return IsInsideContainer(it, PouchUid(ownerUid));
			}
			return false;
		}

		public static bool IsInBag(SavedItem it, string bagUid)
		{
			if (!string.IsNullOrEmpty(bagUid))
			{
				return IsInsideContainer(it, BagContentUid(bagUid));
			}
			return false;
		}

		public static List<SavedItem> WornOf(string ownerUid, IEnumerable<SavedItem> items)
		{
			return Where(items, (SavedItem it) => IsWornBy(it, ownerUid) && it.ItemId > 0);
		}

		public static List<SavedItem> PouchOf(string ownerUid, IEnumerable<SavedItem> items)
		{
			return Where(items, (SavedItem it) => IsInPouchOf(it, ownerUid) && it.ItemId > 0);
		}

		public static List<SavedItem> BagContentsOf(string bagUid, IEnumerable<SavedItem> items)
		{
			return Where(items, (SavedItem it) => IsInBag(it, bagUid) && it.ItemId > 0);
		}

		public static List<int> EquippedItemIds(string ownerUid, IEnumerable<SavedItem> items)
		{
			List<int> list = new List<int>();
			if (string.IsNullOrEmpty(ownerUid) || items == null)
			{
				return list;
			}
			foreach (SavedItem item in items)
			{
				if (IsWornBy(item, ownerUid) && item.ItemId > 0)
				{
					list.Add(item.ItemId);
				}
			}
			return list;
		}

		public static List<KeyValuePair<int, List<int>>> EquippedItemEnchants(string ownerUid, IEnumerable<SavedItem> items)
		{
			List<KeyValuePair<int, List<int>>> list = new List<KeyValuePair<int, List<int>>>();
			if (string.IsNullOrEmpty(ownerUid) || items == null)
			{
				return list;
			}
			foreach (SavedItem item in items)
			{
				if (IsWornBy(item, ownerUid) && item.ItemId > 0)
				{
					list.Add(new KeyValuePair<int, List<int>>(item.ItemId, EnchantmentIds(item.SubClassesData)));
				}
			}
			return list;
		}

		public static string KnowledgeHierarchy(string ownerUid)
		{
			return "3" + ownerUid;
		}

		public static bool IsKnowledgeOf(SavedItem it, string ownerUid)
		{
			if (!string.IsNullOrEmpty(ownerUid))
			{
				return string.Equals(it.Hierarchy, KnowledgeHierarchy(ownerUid), StringComparison.Ordinal);
			}
			return false;
		}

		public static List<int> KnowledgeItemIds(string ownerUid, IEnumerable<SavedItem> items)
		{
			List<int> list = new List<int>();
			if (string.IsNullOrEmpty(ownerUid) || items == null)
			{
				return list;
			}
			foreach (SavedItem item in items)
			{
				if (IsKnowledgeOf(item, ownerUid) && item.ItemId > 0)
				{
					list.Add(item.ItemId);
				}
			}
			return list;
		}

		public static int QuickslotItemId(string saveData)
		{
			if (string.IsNullOrEmpty(saveData))
			{
				return 0;
			}
			string[] array = saveData.Split(new char[1] { ';' });
			if (array.Length < 2)
			{
				return 0;
			}
			if (!int.TryParse(array[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) || result <= 0)
			{
				return 0;
			}
			return result;
		}

		public static List<SavedItem> Offer(string ownerUid, string bagUid, IEnumerable<SavedItem> items)
		{
			return Where(items, (SavedItem it) => it.ItemId > 0 && (IsInPouchOf(it, ownerUid) || IsInBag(it, bagUid)));
		}

		private static List<SavedItem> Where(IEnumerable<SavedItem> items, Func<SavedItem, bool> pred)
		{
			List<SavedItem> list = new List<SavedItem>();
			if (items == null)
			{
				return list;
			}
			foreach (SavedItem item in items)
			{
				if (pred(item))
				{
					list.Add(item);
				}
			}
			return list;
		}

		public static List<int> EnchantmentIds(string subClassesData)
		{
			List<int> list = new List<int>();
			if (string.IsNullOrEmpty(subClassesData))
			{
				return list;
			}
			string text = null;
			string[] array = subClassesData.Split(new char[1] { ';' });
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].Trim();
				if (text2.Length != 0)
				{
					int num = text2.IndexOf('/');
					string s;
					if (num >= 0)
					{
						text = text2.Substring(0, num);
						s = text2.Substring(num + 1);
					}
					else
					{
						s = text2;
					}
					if (text != null && text.EndsWith("Enchantments", StringComparison.Ordinal) && int.TryParse(s, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) && result > 0 && !list.Contains(result))
					{
						list.Add(result);
					}
				}
			}
			return list;
		}

		public static int NewestFirst(string a, string b)
		{
			return string.CompareOrdinal(b ?? "", a ?? "");
		}
	}
	public static class SaveSnapshotRules
	{
		public enum ItemEdit
		{
			Unchanged,
			Reduced,
			Removed
		}

		public const string SnapshotFormat = "yyyyMMddHHmmss";

		public const string PSaveStampFormat = "yyyy-MM-dd_HH-mm-ss";

		public static string SnapshotName(DateTime now)
		{
			return now.ToString("yyyyMMddHHmmss", CultureInfo.InvariantCulture);
		}

		public static string PSaveStamp(DateTime now)
		{
			return now.ToString("yyyy-MM-dd_HH-mm-ss", CultureInfo.InvariantCulture);
		}

		public static string NextSnapshotName(DateTime now, string newestExisting)
		{
			string text = SnapshotName(now);
			if (string.IsNullOrEmpty(newestExisting) || string.CompareOrdinal(text, newestExisting) > 0)
			{
				return text;
			}
			if (DateTime.TryParseExact(newestExisting, "yyyyMMddHHmmss", CultureInfo.InvariantCulture, DateTimeStyles.None, out var result))
			{
				return SnapshotName(result.AddSeconds(1.0));
			}
			return text;
		}

		public static ItemEdit EditItemEntry(string syncDataXml, int qty, out string newXml)
		{
			newXml = syncDataXml;
			if (string.IsNullOrEmpty(syncDataXml) || qty <= 0)
			{
				return ItemEdit.Unchanged;
			}
			try
			{
				XmlDocument xmlDocument = new XmlDocument();
				xmlDocument.LoadXml(syncDataXml);
				XmlElement xmlElement = xmlDocument["Item"];
				if (xmlElement == null)
				{
					return ItemEdit.Unchanged;
				}
				XmlElement xmlElement2 = xmlElement["Quantity"];
				int num = 1;
				if (xmlElement2 != null && int.TryParse(xmlElement2.InnerText, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) && result > 0)
				{
					num = result;
				}
				if (qty >= num)
				{
					newXml = null;
					return ItemEdit.Removed;
				}
				xmlElement2.InnerText = (num - qty).ToString(CultureInfo.InvariantCulture);
				newXml = xmlDocument.OuterXml;
				return ItemEdit.Reduced;
			}
			catch (XmlException)
			{
				return ItemEdit.Unchanged;
			}
		}
	}
	public enum SpecIssueSeverity
	{
		Warn,
		Error
	}
	public sealed class SpecIssue
	{
		public SpecIssueSeverity Severity;

		public string Message;

		public SpecIssue(SpecIssueSeverity severity, string message)
		{
			Severity = severity;
			Message = message;
		}

		public override string ToString()
		{
			return Severity.ToString() + ": " + Message;
		}
	}
	public static class SpecValidation
	{
		public const int MaxMenuDepth = 3;

		public static List<SpecIssue> Validate(NpcSpec spec)
		{
			List<SpecIssue> list = new List<SpecIssue>();
			if (spec == null)
			{
				list.Add(new SpecIssue(SpecIssueSeverity.Error, "spec is null"));
				return list;
			}
			if (string.IsNullOrEmpty(spec.Id))
			{
				list.Add(new SpecIssue(SpecIssueSeverity.Error, "spec has no Id"));
			}
			if (string.IsNullOrEmpty(spec.Name))
			{
				list.Add(new SpecIssue(SpecIssueSeverity.Error, "spec has no Name"));
			}
			bool flag = spec.Trainer != null;
			if (flag && (spec.Trainer.Tree == null || string.IsNullOrEmpty(spec.Trainer.SkillTreeUID)))
			{
				list.Add(new SpecIssue(SpecIssueSeverity.Error, "TrainerSpec present but SkillTreeUID/Tree missing — an unsellable trainer"));
			}
			int num = ((spec.Placements != null) ? spec.Placements.Count : 0);
			if (num == 0)
			{
				list.Add(new SpecIssue(SpecIssueSeverity.Warn, "no Placement — spawnable only via verbs."));
			}
			else if (num > 1)
			{
				list.Add(new SpecIssue(SpecIssueSeverity.Warn, num + " placements — v1 uses Placements[0] only (rotation/conditions are the deferred §5 axis)."));
			}
			if (spec.Dialogue == null)
			{
				list.Add(new SpecIssue(SpecIssueSeverity.Error, "Dialogue is required (an NPC with no DialogueSpec cannot be rigged)"));
				return list;
			}
			if (spec.Combat != null && !spec.Mobile)
			{
				list.Add(new SpecIssue(SpecIssueSeverity.Error, "CombatSpec requires Mobile=true — a pinned, AI-less body has nothing to fight with."));
			}
			if (spec.Ai != null && !spec.Mobile)
			{
				list.Add(new SpecIssue(SpecIssueSeverity.Warn, "AiSpec is ignored unless Mobile=true (no AI is built for a static NPC)."));
			}
			if (spec.Combat != null && spec.Combat.DamageResists != null && spec.Combat.DamageResists.Length != 6)
			{
				list.Add(new SpecIssue(SpecIssueSeverity.Error, "CombatSpec.DamageResists must have exactly 6 entries (Physical, Ethereal, Decay, Electric, Frost, Fire)."));
			}
			if (spec.Merchant != null && !spec.Mobile)
			{
				list.Add(new SpecIssue(SpecIssueSeverity.Error, "MerchantSpec requires Mobile=true — the Merchant graft rides the mobile rig, so a static NPC would never get a shop."));
			}
			if (spec.Merchant != null && spec.Merchant.RefreshRateGameHours < 0f)
			{
				list.Add(new SpecIssue(SpecIssueSeverity.Error, "MerchantSpec.RefreshRateGameHours must be >= 0."));
			}
			if (spec.OutfitPool != null)
			{
				int num2 = 0;
				foreach (OutfitSpec item in spec.OutfitPool)
				{
					if (item == null || item.IsEmpty)
					{
						num2++;
					}
				}
				if (num2 > 0)
				{
					list.Add(new SpecIssue(SpecIssueSeverity.Warn, num2 + " empty OutfitPool entr" + ((num2 == 1) ? "y" : "ies") + " — rolling one of those leaves the NPC in the spec's explicit ids (or bare)."));
				}
			}
			bool wantsTrain = false;
			bool wantsShop = false;
			int visibleChoices = 0;
			WalkChoices(spec.Dialogue.Choices, 0, new List<Choice>(), list, ref wantsTrain, ref wantsShop, ref visibleChoices);
			if (flag && wantsTrain)
			{
				visibleChoices++;
			}
			bool num3 = spec.Merchant != null;
			if (num3 && wantsShop)
			{
				visibleChoices++;
			}
			if (!num3 && wantsShop)
			{
				list.Add(new SpecIssue(SpecIssueSeverity.Error, "a Shop choice with no MerchantSpec — there is no shop to open."));
			}
			if (num3 && !wantsShop)
			{
				list.Add(new SpecIssue(SpecIssueSeverity.Warn, "MerchantSpec present but no Shop choice in the dialogue — the shop will be unreachable in conversation."));
			}
			if (visibleChoices == 0)
			{
				list.Add(new SpecIssue(SpecIssueSeverity.Warn, "no visible dialogue choices — greeting-only NPC (the conversation ends after the greeting)."));
			}
			if (flag && !wantsTrain)
			{
				list.Add(new SpecIssue(SpecIssueSeverity.Warn, "no Train choice in the dialogue — the skill tree will be unreachable in conversation."));
			}
			if (!flag && wantsTrain)
			{
				list.Add(new SpecIssue(SpecIssueSeverity.Warn, "a Train choice with no TrainerSpec — the choice is dropped from the dialogue (plain NPC)."));
			}
			return list;
		}

		private static void WalkChoices(List<Choice> rows, int depth, List<Choice> ancestors, List<SpecIssue> issues, ref bool wantsTrain, ref bool wantsShop, ref int visibleChoices)
		{
			if (rows == null)
			{
				return;
			}
			foreach (Choice row in rows)
			{
				if (row == null)
				{
					continue;
				}
				if (row.Kind == ChoiceKind.Shop)
				{
					if (depth > 0)
					{
						issues.Add(new SpecIssue(SpecIssueSeverity.Warn, "choice '" + row.Id + "': a Shop choice inside a submenu is dropped — Shop belongs at the root."));
					}
					else
					{
						wantsShop = true;
					}
					continue;
				}
				if (row.Kind == ChoiceKind.Train)
				{
					if (depth > 0)
					{
						issues.Add(new SpecIssue(SpecIssueSeverity.Warn, "choice '" + row.Id + "': a Train choice inside a submenu is dropped — Train belongs at the root."));
					}
					else
					{
						wantsTrain = true;
					}
					continue;
				}
				if (row.Kind == ChoiceKind.Action && string.IsNullOrEmpty(row.ActionId))
				{
					issues.Add(new SpecIssue(SpecIssueSeverity.Error, "choice '" + row.Id + "': Kind=Action with no ActionId — there is no callback to run."));
				}
				if (depth == 0)
				{
					visibleChoices++;
				}
				if (row.Kind == ChoiceKind.Menu)
				{
					if (row.Children == null || row.Children.Count == 0)
					{
						issues.Add(new SpecIssue(SpecIssueSeverity.Error, "choice '" + row.Id + "': Kind=Menu with no Children — an empty submenu has nothing to connect."));
					}
					else if (ContainsReference(ancestors, row))
					{
						issues.Add(new SpecIssue(SpecIssueSeverity.Error, "choice '" + row.Id + "': submenu cycle — this menu is reachable from itself."));
					}
					else if (depth + 1 > 3)
					{
						issues.Add(new SpecIssue(SpecIssueSeverity.Error, "choice '" + row.Id + "': submenu nesting exceeds MaxMenuDepth (" + 3 + ")."));
					}
					else
					{
						ancestors.Add(row);
						WalkChoices(row.Children, depth + 1, ancestors, issues, ref wantsTrain, ref wantsShop, ref visibleChoices);
						ancestors.RemoveAt(ancestors.Count - 1);
					}
				}
			}
		}

		private static bool ContainsReference(List<Choice> list, Choice c)
		{
			foreach (Choice item in list)
			{
				if (item == c)
				{
					return true;
				}
			}
			return false;
		}

		public static bool HasErrors(List<SpecIssue> issues)
		{
			if (issues == null)
			{
				return false;
			}
			foreach (SpecIssue issue in issues)
			{
				if (issue.Severity == SpecIssueSeverity.Error)
				{
					return true;
				}
			}
			return false;
		}

		public static string FirstError(List<SpecIssue> issues)
		{
			if (issues == null)
			{
				return null;
			}
			foreach (SpecIssue issue in issues)
			{
				if (issue.Severity == SpecIssueSeverity.Error)
				{
					return issue.Message;
				}
			}
			return null;
		}
	}
	public static class TorsoLook
	{
		public static bool ShouldMute(bool locked, bool hasWeapon, bool rangeSkillAim, bool chargingAttack, bool sprinting)
		{
			if (sprinting)
			{
				return false;
			}
			if (!locked)
			{
				return false;
			}
			if (rangeSkillAim || chargingAttack)
			{
				return false;
			}
			if (hasWeapon)
			{
				return false;
			}
			return true;
		}
	}
	public enum TreeIssueSeverity
	{
		Warn,
		Error
	}
	public sealed class TreeIssue
	{
		public TreeIssueSeverity Severity;

		public string Message;

		public TreeIssue(TreeIssueSeverity severity, string message)
		{
			Severity = severity;
			Message = message;
		}

		public override string ToString()
		{
			return $"{Severity}: {Message}";
		}
	}
	public static class TreeLayout
	{
		public const int MinRow = 1;

		public const int MaxRow = 5;

		public const int MinColumn = 1;

		public const int MaxColumn = 3;

		public const int BreakthroughRow = 3;

		public static List<TreeIssue> Validate(SkillTreeDef tree)
		{
			List<TreeIssue> list = new List<TreeIssue>();
			if (tree == null)
			{
				list.Add(Error("tree is null"));
				return list;
			}
			if (string.IsNullOrEmpty(tree.Name))
			{
				list.Add(Error("tree has no Name"));
			}
			if (tree.Slots == null || tree.Slots.Count == 0)
			{
				list.Add(Error("tree '" + tree.Name + "' has no slots"));
				return list;
			}
			HashSet<(int, int)> hashSet = new HashSet<(int, int)>();
			HashSet<int> hashSet2 = new HashSet<int>();
			foreach (SlotDef s in tree.Slots)
			{
				string text = $"slot ({s.Row},{s.Column}) skill {s.SkillId}";
				if (s.Row < 1 || s.Row > 5)
				{
					list.Add(Error($"{text}: Row must be {1}-{5}"));
				}
				if (s.Column < 1 || s.Column > 3)
				{
					list.Add(Error($"{text}: Column must be {1}-{3}"));
				}
				if (s.SkillId == 0)
				{
					list.Add(Error(text + ": SkillId is 0"));
				}
				if (s.SilverCost < 0)
				{
					list.Add(Error(text + ": negative SilverCost"));
				}
				if (!hashSet.Add((s.Row, s.Column)))
				{
					list.Add(Error($"{text}: duplicate cell — another slot already occupies ({s.Row},{s.Column})"));
				}
				if (s.SkillId != 0 && !hashSet2.Add(s.SkillId))
				{
					list.Add(Error($"{text}: duplicate SkillId {s.SkillId}"));
				}
				if (s.RequiredRow != 0 || s.RequiredColumn != 0)
				{
					if (s.RequiredRow == 0 || s.RequiredColumn == 0)
					{
						list.Add(Error($"{text}: prerequisite is half-set ({s.RequiredRow},{s.RequiredColumn}) — both row and column, or neither"));
					}
					else if (!tree.Slots.Any((SlotDef o) => o != s && o.Row == s.RequiredRow && o.Column == s.RequiredColumn))
					{
						list.Add(Error($"{text}: prerequisite ({s.RequiredRow},{s.RequiredColumn}) names no slot in this tree"));
					}
					if (s.RequiredRow == s.Row && s.RequiredColumn == s.Column)
					{
						list.Add(Error(text + ": prerequisite points at itself"));
					}
				}
				if (s.Breakthrough && s.Row != 3)
				{
					list.Add(Error($"{text}: Breakthrough outside row {3} — vanilla trees keep the breakthrough on row {3}"));
				}
			}
			Dictionary<(int, int), SlotDef> dictionary = new Dictionary<(int, int), SlotDef>();
			foreach (SlotDef slot in tree.Slots)
			{
				if (!dictionary.ContainsKey((slot.Row, slot.Column)))
				{
					dictionary[(slot.Row, slot.Column)] = slot;
				}
			}
			HashSet<(int, int)> hashSet3 = new HashSet<(int, int)>();
			foreach (SlotDef slot2 in tree.Slots)
			{
				HashSet<(int, int)> hashSet4 = new HashSet<(int, int)> { (slot2.Row, slot2.Column) };
				List<string> list2 = new List<string> { $"({slot2.Row},{slot2.Column})" };
				SlotDef slotDef = slot2;
				SlotDef value;
				while (slotDef.RequiredRow != 0 && slotDef.RequiredColumn != 0 && dictionary.TryGetValue((slotDef.RequiredRow, slotDef.RequiredColumn), out value))
				{
					list2.Add($"({value.Row},{value.Column})");
					if (!hashSet4.Add((value.Row, value.Column)))
					{
						if (hashSet3.Add((slot2.Row, slot2.Column)))
						{
							list.Add(Error("tree '" + tree.Name + "': prerequisite CYCLE " + string.Join(" -> ", list2.ToArray()) + " — no slot on this chain can ever be unlocked"));
						}
						break;
					}
					slotDef = value;
				}
			}
			int num = tree.Slots.Count((SlotDef slotDef2) => slotDef2.Breakthrough);
			if (num == 0)
			{
				list.Add(Error("tree '" + tree.Name + "' has no breakthrough slot — vanilla trees have exactly one"));
			}
			else if (num > 1)
			{
				list.Add(Error($"tree '{tree.Name}' has {num} breakthrough slots — vanilla trees have exactly one"));
			}
			return list;
		}

		public static bool HasErrors(IEnumerable<TreeIssue> issues)
		{
			return issues?.Any((TreeIssue i) => i.Severity == TreeIssueSeverity.Error) ?? false;
		}

		private static TreeIssue Error(string msg)
		{
			return new TreeIssue(TreeIssueSeverity.Error, msg);
		}

		private static TreeIssue Warn(string msg)
		{
			return new TreeIssue(TreeIssueSeverity.Warn, msg);
		}
	}
	public struct VisualBounds
	{
		public int Skins;

		public int FemaleSkins;

		public int MaleHeadsWhite;

		public int MaleHeadsBlack;

		public int MaleHeadsAsian;

		public int FemaleHeadsWhite;

		public int FemaleHeadsBlack;

		public int FemaleHeadsAsian;

		public int Hairs;

		public int HairColors;
	}
	public struct VisualPick
	{
		public int Gender;

		public int SkinIndex;

		public int HeadVariationIndex;

		public int HairStyleIndex;

		public int HairColorIndex;

		public override string ToString()
		{
			return $"gender={Gender} skin={SkinIndex} head={HeadVariationIndex} hair={HairStyleIndex} hairColor={HairColorIndex}";
		}
	}
	public static class VisualRoll
	{
		public static int Seed(string id, int sessionSalt)
		{
			uint num = 2166136261u;
			if (id != null)
			{
				foreach (char c in id)
				{
					num ^= c;
					num *= 16777619;
				}
			}
			return (int)num ^ sessionSalt;
		}

		public static double Roll01(int seed, int stream)
		{
			return new Random(seed + stream * 7919).NextDouble();
		}

		public static VisualPick Roll(int seed, VisualBounds b)
		{
			Random random = new Random(seed);
			VisualPick result = new VisualPick
			{
				Gender = random.Next(0, 2)
			};
			int bound = ((result.Gender == 1 && b.FemaleSkins > 0) ? b.FemaleSkins : b.Skins);
			result.SkinIndex = Next(random, bound);
			int bound2 = ((result.SkinIndex == 0) ? ((result.Gender == 0) ? b.MaleHeadsWhite : b.FemaleHeadsWhite) : ((result.SkinIndex != 1) ? ((result.Gender == 0) ? b.MaleHeadsAsian : b.FemaleHeadsAsian) : ((result.Gender == 0) ? b.MaleHeadsBlack : b.FemaleHeadsBlack)));
			result.HeadVariationIndex = Next(random, bound2);
			result.HairStyleIndex = Next(random, b.Hairs);
			result.HairColorIndex = Next(random, b.HairColors);
			return result;
		}

		private static int Next(Random r, int bound)
		{
			if (bound > 0)
			{
				return r.Next(0, bound);
			}
			return 0;
		}
	}
}