using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using GUIFramework;
using HarmonyLib;
using LostScrollsII.Bounty;
using LostScrollsII.Companions;
using LostScrollsII.Economy;
using LostScrollsII.Integration;
using LostScrollsII.Ranking;
using Microsoft.CodeAnalysis;
using Splatform;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.UI;
using ValheimServerGuide.Discord;
using ValheimServerGuide.Triggers;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("assembly_valheim")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("LostScrollsII")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.9.1.0")]
[assembly: AssemblyInformationalVersion("0.9.1+7b81ffa85b20e1622905f275f7685e83d3fed6dd")]
[assembly: AssemblyProduct("LostScrollsII")]
[assembly: AssemblyTitle("LostScrollsII")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.9.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[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 LostScrollsII
{
	[BepInPlugin("com.lostscrollsii", "Lost Scrolls II", "0.9.1")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		public const string PluginGuid = "com.lostscrollsii";

		public const string PluginName = "Lost Scrolls II";

		public const string PluginVersion = "0.9.1";

		private Harmony _harmony;

		public static Plugin Instance { get; private set; }

		public static ManualLogSource Log { get; private set; }

		public static ConfigEntry<KeyCode> CommunionKey { get; private set; }

		public static ConfigEntry<float> CommunionChannelSeconds { get; private set; }

		public static ConfigEntry<float> CommunionMaxDistance { get; private set; }

		public static ConfigEntry<bool> CommunionBreakOnDamage { get; private set; }

		public static ConfigEntry<bool> StaffSealEnabled { get; private set; }

		public static ConfigEntry<int> SealMinBloodMagic { get; private set; }

		public static ConfigEntry<int> SealFullSpeedBloodMagic { get; private set; }

		public static ConfigEntry<float> SealChannelMaxSeconds { get; private set; }

		public static ConfigEntry<float> SealChannelMinSeconds { get; private set; }

		public static ConfigEntry<float> SealMaxDistance { get; private set; }

		public static ConfigEntry<KeyCode> ChoreAssignKey { get; private set; }

		public static ConfigEntry<float> ChoreAssignRadius { get; private set; }

		public static ConfigEntry<KeyCode> DuelSelectKey { get; private set; }

		public static ConfigEntry<KeyCode> PartyDuelKey { get; private set; }

		public static ConfigEntry<int> MaxPartySize { get; private set; }

		public static ConfigEntry<KeyCode> StanceCycleKey { get; private set; }

		public static ConfigEntry<KeyCode> InventoryKey { get; private set; }

		public static ConfigEntry<bool> ShowMapPins { get; private set; }

		public static ConfigEntry<string> CompanionPinColor { get; private set; }

		public static ConfigEntry<float> CompanionPinScale { get; private set; }

		public static ConfigEntry<bool> ShowDeathMarker { get; private set; }

		public static ConfigEntry<bool> MoveContainerPanel { get; private set; }

		public static ConfigEntry<string> ContainerPanelOffset { get; private set; }

		public static ConfigEntry<string> MenuBarOffset { get; private set; }

		public static ConfigEntry<int> RankingKFactor { get; private set; }

		public static ConfigEntry<float> RankingPairCooldown { get; private set; }

		public static ConfigEntry<bool> ShowRankOnNameTag { get; private set; }

		public static ConfigEntry<KeyCode> RankingUiKey { get; private set; }

		public static ConfigEntry<KeyCode> TournamentUiKey { get; private set; }

		public static ConfigEntry<int> RequiredEntrantLevel { get; private set; }

		public static ConfigEntry<int> MaxEntrants { get; private set; }

		public static ConfigEntry<bool> WagersEnabled { get; private set; }

		public static ConfigEntry<int> TournamentValcoinFee { get; private set; }

		public static ConfigEntry<int> TournamentValcoinPrize { get; private set; }

		public static ConfigEntry<int> TournamentCoinFee { get; private set; }

		public static ConfigEntry<int> TournamentCoinPrize { get; private set; }

		public static ConfigEntry<int> DuelValcoinStake { get; private set; }

		public static ConfigEntry<int> DuelCoinStake { get; private set; }

		public static ConfigEntry<int> WageredBracketSize { get; private set; }

		public static ConfigEntry<float> WageredRegistrationMinutes { get; private set; }

		public static ConfigEntry<bool> BountyEnabled { get; private set; }

		public static ConfigEntry<float> BountySearchMinRadius { get; private set; }

		public static ConfigEntry<float> BountySearchMaxRadius { get; private set; }

		public static ConfigEntry<float> BountyLandCheckRadius { get; private set; }

		public static ConfigEntry<float> BountyWaterMargin { get; private set; }

		public static ConfigEntry<float> BountyMaxHeightVariance { get; private set; }

		public static ConfigEntry<int> BountySampleAttempts { get; private set; }

		public static ConfigEntry<int> BountyTierBlackForest { get; private set; }

		public static ConfigEntry<int> BountyTierSwamp { get; private set; }

		public static ConfigEntry<int> BountyTierMountain { get; private set; }

		public static ConfigEntry<int> BountyTierPlains { get; private set; }

		public static ConfigEntry<float> BountyHealthBase { get; private set; }

		public static ConfigEntry<float> BountyHealthGrowth { get; private set; }

		public static ConfigEntry<int> BountyMaxStarLevel { get; private set; }

		public static ConfigEntry<int> BountyMinionsBase { get; private set; }

		public static ConfigEntry<int> BountyMinionsPerTier { get; private set; }

		public static ConfigEntry<int> BountyMaxMinions { get; private set; }

		public static ConfigEntry<float> BountyMinionRingRadius { get; private set; }

		public static ConfigEntry<float> BountyAlertRangeMultiplier { get; private set; }

		public static ConfigEntry<float> BountyRoamRadius { get; private set; }

		public static ConfigEntry<int> BountyMaxTierBonus { get; private set; }

		public static ConfigEntry<float> BountyValcoinBaseChance { get; private set; }

		public static ConfigEntry<float> BountyValcoinChancePerTier { get; private set; }

		public static ConfigEntry<float> BountyValcoinRankBonus { get; private set; }

		public static ConfigEntry<int> BountyValcoinRankDepth { get; private set; }

		public static ConfigEntry<float> BountyValcoinMaxChance { get; private set; }

		public static ConfigEntry<int> BountyPointsPerTier { get; private set; }

		public static ConfigEntry<int> BountyLeaderboardBonusRank { get; private set; }

		public static ConfigEntry<KeyCode> BountyUiKey { get; private set; }

		public static ConfigEntry<int> BountyMaxBoardEntries { get; private set; }

		public static ConfigEntry<int> BountyMaxActivePerPlayer { get; private set; }

		public static ConfigEntry<float> BountyArrivalRadius { get; private set; }

		public static ConfigEntry<string> BountyButtonOffset { get; private set; }

		public static ConfigEntry<float> BountyRefreshHours { get; private set; }

		public static ConfigEntry<float> BountyEliteChance { get; private set; }

		public static ConfigEntry<int> BountyEliteRankTopN { get; private set; }

		private void Awake()
		{
			//IL_0a34: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a3e: Expected O, but got Unknown
			Instance = this;
			Log = ((BaseUnityPlugin)this).Logger;
			CommunionKey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("Recruitment", "CommunionKey", (KeyCode)103, "Key pressed while hovering a recruited companion to feed it a health mead. (The Communion Rite that recruits a subdued Dvergr is now channeled by holding the Block button, not this key.)");
			CommunionChannelSeconds = ((BaseUnityPlugin)this).Config.Bind<float>("Recruitment", "CommunionChannelSeconds", 5f, "How long you must hold the Communion key to complete the rite. The corruption fights back the whole time — release the key, stray too far, or take a hit and the rite breaks.");
			CommunionMaxDistance = ((BaseUnityPlugin)this).Config.Bind<float>("Recruitment", "CommunionMaxDistance", 4f, "How far you may drift from the Dvergr mid-rite before the connection snaps and the rite fails.");
			CommunionBreakOnDamage = ((BaseUnityPlugin)this).Config.Bind<bool>("Recruitment", "CommunionBreakOnDamage", true, "If true, taking damage while channeling the Communion Rite breaks it (the shadow reclaims the Dvergr). Turn off for a more forgiving rite.");
			StaffSealEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("Recruitment", "StaffSealEnabled", true, "Allow sealing a companion into a Communion Totem in the field with an equipped Dead Raiser (StaffSkeleton) + a Wisp, by holding Block on your own Follow-stance ally. The Incinerator ritual is unaffected either way.");
			SealMinBloodMagic = ((BaseUnityPlugin)this).Config.Bind<int>("Recruitment", "SealMinBloodMagic", 20, "Minimum Blood Magic skill needed to seal a companion with a Dead Raiser. Below this the rite cannot be started.");
			SealFullSpeedBloodMagic = ((BaseUnityPlugin)this).Config.Bind<int>("Recruitment", "SealFullSpeedBloodMagic", 100, "The Blood Magic skill at which the sealing channel reaches its fastest (SealChannelMinSeconds). Between SealMinBloodMagic and this value the channel time scales smoothly.");
			SealChannelMaxSeconds = ((BaseUnityPlugin)this).Config.Bind<float>("Recruitment", "SealChannelMaxSeconds", 5f, "How long the Dead Raiser sealing channel takes at the MINIMUM Blood Magic skill (the slowest it ever is).");
			SealChannelMinSeconds = ((BaseUnityPlugin)this).Config.Bind<float>("Recruitment", "SealChannelMinSeconds", 2f, "How long the Dead Raiser sealing channel takes at SealFullSpeedBloodMagic (the fastest it ever is).");
			SealMaxDistance = ((BaseUnityPlugin)this).Config.Bind<float>("Recruitment", "SealMaxDistance", 4f, "How far you may drift from the companion mid-sealing before the binding fails.");
			ChoreAssignKey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("Chores", "ChoreAssignKey", (KeyCode)104, "Key pressed while hovering a workstation (Smelter-family), a ripe crop, or a tamed animal to assign/unassign the nearest matching-caste companion to that chore.");
			ChoreAssignRadius = ((BaseUnityPlugin)this).Config.Bind<float>("Chores", "ChoreAssignRadius", 10f, "Max distance from the player to look for a recruited companion to assign to a chore.");
			DuelSelectKey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("Duels", "DuelSelectKey", (KeyCode)106, "Press while hovering your own recruited companion to toggle its duel mode. A duel-mode companion fights other players' duel-mode companions and ignores everyone else.");
			PartyDuelKey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("Duels", "PartyDuelKey", (KeyCode)107, "Press while hovering your own recruited companion to toggle a party duel: your nearby Follow-stance companions form a team that fights another player's party-duel team.");
			MaxPartySize = ((BaseUnityPlugin)this).Config.Bind<int>("Duels", "MaxPartySize", 4, "Maximum number of your companions that join a party duel when you toggle it on.");
			StanceCycleKey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("Companions", "StanceCycleKey", (KeyCode)101, "Press while hovering your companion to cycle its stance: Follow -> Guard -> Standby.");
			InventoryKey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("Companions", "InventoryKey", (KeyCode)121, "Press while hovering your companion to open its inventory (a chest-like panel that also lets you rename it).");
			ShowMapPins = ((BaseUnityPlugin)this).Config.Bind<bool>("Companions", "ShowMapPins", true, "Show a live minimap pin at each of your own recruited companions. Pins are client-side — other players never see your companions, and you never see theirs.");
			CompanionPinColor = ((BaseUnityPlugin)this).Config.Bind<string>("Companions", "CompanionPinColor", "FFB84D", "Hex tint (RRGGBB) for companion map pins, which use the player icon in a smaller size. Distinguishes your allies from your own marker.");
			CompanionPinScale = ((BaseUnityPlugin)this).Config.Bind<float>("Companions", "CompanionPinScale", 0.7f, "Size multiplier for companion map pins (1 = full player-icon size). Smaller keeps them from crowding your own marker.");
			ShowDeathMarker = ((BaseUnityPlugin)this).Config.Bind<bool>("Companions", "ShowDeathMarker", true, "Drop a persistent death marker (skull) on your map, labelled with the companion's name, when one of your companions dies.");
			MoveContainerPanel = ((BaseUnityPlugin)this).Config.Bind<bool>("Interface", "MoveContainerPanel", true, "Let the chest/storage UI be repositioned: it opens at ContainerPanelOffset, and you can drag it anywhere on screen by grabbing an empty part of the panel. Set to false to leave the panel exactly where the game puts it. Automatically ignored when BiomeLords is installed (it moves the same panel itself).");
			ContainerPanelOffset = ((BaseUnityPlugin)this).Config.Bind<string>("Interface", "ContainerPanelOffset", "auto", "Where the chest/storage UI sits, as an \"x,y\" pixel offset from the game's own position (+x right, +y up). \"auto\" places it two inventory rows below, so extra rows added by other mods aren't hidden behind it. Dragging the panel writes the new value here; set it back to \"auto\" to restore the default position.");
			MenuBarOffset = ((BaseUnityPlugin)this).Config.Bind<string>("Interface", "MenuBarOffset", "0,0", "Nudge the row of menu buttons at the top of the inventory screen by \"x,y\" pixels (+x right, +y up). The row holds Rankings, Tournaments and Bounty Board; the matching function keys keep working either way.");
			RankingKFactor = ((BaseUnityPlugin)this).Config.Bind<int>("Ranking", "EloKFactor", 32, "Elo K-factor for the duel ladder — higher means bigger rating swings per match.");
			RankingPairCooldown = ((BaseUnityPlugin)this).Config.Bind<float>("Ranking", "PairCooldownSeconds", 300f, "Seconds before the same two companions can move each other's rating again (W/L still count). Anti friend-farming.");
			ShowRankOnNameTag = ((BaseUnityPlugin)this).Config.Bind<bool>("Ranking", "ShowRankOnNameTag", true, "Append the ladder rank (e.g. #3) to a companion's floating name when it has one.");
			RankingUiKey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("Ranking", "RankingUiKey", (KeyCode)287, "Opens the ranking board — a read-only view of the duel and party ladders. Close it with Escape, like reading a runestone. (de_ladder / de_party_ladder still work in the console.)");
			TournamentUiKey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("Tournaments", "TournamentUiKey", (KeyCode)288, "Opens the tournament board — status, registration (lock a companion's Communion Totem into a slot to enter), the bracket, and admin controls. (de_tournament still works in the console.)");
			RequiredEntrantLevel = ((BaseUnityPlugin)this).Config.Bind<int>("Tournaments", "RequiredEntrantLevel", 0, "0 = no restriction. When >0, a 1v1 entrant's companion level must match this exactly to be allowed to register (party entries are not level-gated).");
			MaxEntrants = ((BaseUnityPlugin)this).Config.Bind<int>("Tournaments", "MaxEntrants", 4, "Hard cap on tournament entrants. `de_tournament start` clamps any size above this, and a size of 0 (or omitted) now means \"use this cap\" instead of unlimited.");
			WagersEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("Wagers", "WagersEnabled", true, "Master switch for wagered events: player-started tournaments and duel invites staked in Coins or Valcoins. Turn off to leave only the free admin-run tournaments.");
			WageredBracketSize = ((BaseUnityPlugin)this).Config.Bind<int>("Wagers", "BracketSize", 4, "How many entrants a wagered tournament needs. The bracket starts automatically once it is full, and a tournament that never fills is cancelled with every stake refunded.");
			WageredRegistrationMinutes = ((BaseUnityPlugin)this).Config.Bind<float>("Wagers", "RegistrationMinutes", 30f, "How long a wagered tournament stays open for registration before it is auto-cancelled and every stake refunded. 0 = never expire (the host or an admin must cancel it).");
			TournamentCoinFee = ((BaseUnityPlugin)this).Config.Bind<int>("Wagers", "TournamentCoinFee", 100, "Coins it costs to START a Coin tournament, and the same amount each entrant pays to register.");
			TournamentCoinPrize = ((BaseUnityPlugin)this).Config.Bind<int>("Wagers", "TournamentCoinPrize", 999, "Coins paid to the champion of a Coin tournament.");
			TournamentValcoinFee = ((BaseUnityPlugin)this).Config.Bind<int>("Wagers", "TournamentValcoinFee", 10, "Valcoins it costs to START a Valcoin tournament, and the same amount each entrant pays to register. Requires the Valheim Donations wallet API on the server.");
			TournamentValcoinPrize = ((BaseUnityPlugin)this).Config.Bind<int>("Wagers", "TournamentValcoinPrize", 100, "Valcoins the champion of a Valcoin tournament receives. DISPLAY ONLY on this side: the actual payout is minted by the donations mod from its own valcoin_quests.yaml entry `ls_tournament_prize`, which is the only place allowed to price a Valcoin reward. Keep the two numbers in step.");
			DuelCoinStake = ((BaseUnityPlugin)this).Config.Bind<int>("Wagers", "DuelCoinStake", 100, "Coins staked by each side of a Coin duel invite. The winner takes both stakes.");
			DuelValcoinStake = ((BaseUnityPlugin)this).Config.Bind<int>("Wagers", "DuelValcoinStake", 10, "Valcoins staked by each side of a Valcoin duel invite. The winner takes both stakes — no Valcoins are created, they only change hands.");
			BountyEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("Bounty", "Enabled", true, "Master switch for bounty hunting. Even when true the feature only runs on a server/host that ALSO has BiomeLords, ValheimServerGuide and Valheim Donations installed — set it to false to switch bounties off on a server that would otherwise qualify. Check the log line \"[bounty] feature gate: ON/OFF\" to see which condition failed.");
			BountySearchMinRadius = ((BaseUnityPlugin)this).Config.Bind<float>("Bounty", "SearchMinRadius", 500f, "Closest a bounty may be posted to the world centre, in metres. Keeps targets out of the starting area.");
			BountySearchMaxRadius = ((BaseUnityPlugin)this).Config.Bind<float>("Bounty", "SearchMaxRadius", 6000f, "Furthest a bounty may be posted from the world centre, in metres. Keep well inside the world edge (~10000) so candidates don't fall into the edge ocean.");
			BountyLandCheckRadius = ((BaseUnityPlugin)this).Config.Bind<float>("Bounty", "LandCheckRadius", 80f, "How far around a candidate spot the ground must be dry land, in metres. Checked as three rings — clearing the outermost means the landmass is at least twice this across, which is what rules out islets and narrow spits. Lower it only if bounties become hard to place.");
			BountyWaterMargin = ((BaseUnityPlugin)this).Config.Bind<float>("Bounty", "WaterMargin", 3f, "How far above sea level the ground must sit, in metres, to count as dry. Raise it to push bounties further inland from shorelines.");
			BountyMaxHeightVariance = ((BaseUnityPlugin)this).Config.Bind<float>("Bounty", "MaxHeightVariance", 10f, "Largest height swing allowed in the immediate area around a bounty, in metres. Rejects cliff faces and spires where a fight can't happen. Raise it for more mountain bounties.");
			BountySampleAttempts = ((BaseUnityPlugin)this).Config.Bind<int>("Bounty", "SampleAttempts", 200, "How many random spots to test before giving up on placing one bounty. Higher is slower but more reliable on worlds with little qualifying land.");
			BountyTierBlackForest = ((BaseUnityPlugin)this).Config.Bind<int>("Bounty", "TierBlackForest", 1, "Base difficulty tier (1-5) for bounties posted in the Black Forest.");
			BountyTierSwamp = ((BaseUnityPlugin)this).Config.Bind<int>("Bounty", "TierSwamp", 2, "Base difficulty tier (1-5) for bounties posted in the Swamp.");
			BountyTierMountain = ((BaseUnityPlugin)this).Config.Bind<int>("Bounty", "TierMountain", 3, "Base difficulty tier (1-5) for bounties posted in the Mountains.");
			BountyTierPlains = ((BaseUnityPlugin)this).Config.Bind<int>("Bounty", "TierPlains", 4, "Base difficulty tier (1-5) for bounties posted in the Plains.");
			BountyHealthBase = ((BaseUnityPlugin)this).Config.Bind<float>("Bounty", "HealthMultiplierBase", 3f, "Health multiplier for a tier 1 bounty target, over the creature's normal health. Applied on top of its star level.");
			BountyHealthGrowth = ((BaseUnityPlugin)this).Config.Bind<float>("Bounty", "HealthMultiplierGrowth", 1.6f, "How much the health multiplier compounds per tier. With the defaults: tier 1 = 3x, tier 2 = 4.8x, tier 3 = 7.7x, tier 4 = 12.3x, tier 5 = 19.7x.");
			BountyMaxStarLevel = ((BaseUnityPlugin)this).Config.Bind<int>("Bounty", "MaxStarLevel", 3, "Cap on the vanilla star level given to a bounty target. Stars carry DAMAGE scaling, so raising this makes targets hit far harder, not just survive longer — most of a tier's difficulty is meant to come from health and escort size instead.");
			BountyMinionsBase = ((BaseUnityPlugin)this).Config.Bind<int>("Bounty", "MinionsBase", 1, "How many escort minions a tier 1 bounty target has.");
			BountyMinionsPerTier = ((BaseUnityPlugin)this).Config.Bind<int>("Bounty", "MinionsPerTier", 1, "Extra escort minions added per tier above 1.");
			BountyMaxMinions = ((BaseUnityPlugin)this).Config.Bind<int>("Bounty", "MaxMinions", 6, "Hard cap on escort minions, whatever the tier. Bounds the AI load of one fight.");
			BountyMinionRingRadius = ((BaseUnityPlugin)this).Config.Bind<float>("Bounty", "MinionRingRadius", 6f, "How far from the bounty target its escort spawns, in metres.");
			BountyAlertRangeMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Bounty", "AlertRangeMultiplier", 2f, "How much further than normal a bounty creature notices hunters. Bounty Dvergr hunt on sight rather than waiting to be provoked, so they notice you first.");
			BountyRoamRadius = ((BaseUnityPlugin)this).Config.Bind<float>("Bounty", "RoamRadius", 12f, "How far a bounty creature wanders from where it was posted, in metres. Keeps the map pin meaningful; it still chases hunters normally.");
			BountyMaxTierBonus = ((BaseUnityPlugin)this).Config.Bind<int>("Bounty", "MaxTierBonus", 1, "How many tiers a top-standing bounty hunter's rewards may be bumped by. The bump selects a higher-tier reward entry, so better hunters get better bundles without a second reward table.");
			BountyValcoinBaseChance = ((BaseUnityPlugin)this).Config.Bind<float>("Bounty", "ValcoinBaseChance", 0.1f, "Chance (0-1) that a tier 1 bounty pays Valcoin, before any rank bonus. Valcoin is a REWARD ONLY — nothing in bounty hunting can be bought with it.");
			BountyValcoinChancePerTier = ((BaseUnityPlugin)this).Config.Bind<float>("Bounty", "ValcoinChancePerTier", 0.05f, "Extra Valcoin chance (0-1) added per tier above 1.");
			BountyValcoinRankBonus = ((BaseUnityPlugin)this).Config.Bind<float>("Bounty", "ValcoinRankBonus", 0.25f, "Extra Valcoin chance (0-1) for the #1 ranked duel/party player, tapering to zero at ValcoinRankDepth. This is what ties the coin payout to the duel and tournament ladders.");
			BountyValcoinRankDepth = ((BaseUnityPlugin)this).Config.Bind<int>("Bounty", "ValcoinRankDepth", 10, "How deep the ladder bonus reaches. At rank 1 the full ValcoinRankBonus applies; at this rank and below, none of it does.");
			BountyValcoinMaxChance = ((BaseUnityPlugin)this).Config.Bind<float>("Bounty", "ValcoinMaxChance", 0.75f, "Hard cap (0-1) on the Valcoin payout chance, so a payout is never guaranteed however high a player ranks.");
			BountyPointsPerTier = ((BaseUnityPlugin)this).Config.Bind<int>("Bounty", "PointsPerTier", 10, "Bounty-ladder points awarded per tier of the bounty answered (tier 3 pays 3x this). Tier-weighting is what stops the board being won by grinding easy postings.");
			BountyLeaderboardBonusRank = ((BaseUnityPlugin)this).Config.Bind<int>("Bounty", "LeaderboardBonusRank", 3, "Hunters ranked this high or better on the bounty ladder get +1 reward tier (capped by MaxTierBonus). 0 disables the bonus entirely.");
			BountyUiKey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("Bounty", "BountyUiKey", (KeyCode)289, "Opens the Wanted Board — open postings, your active bounty, and the hunter standings. There is also a Bounty Board button in your inventory. Close it with Escape.");
			BountyMaxBoardEntries = ((BaseUnityPlugin)this).Config.Bind<int>("Bounty", "MaxBoardEntries", 3, "How many OPEN postings the board keeps available. Postings players have accepted don't count toward this, so the board still offers work while others are out hunting.");
			BountyMaxActivePerPlayer = ((BaseUnityPlugin)this).Config.Bind<int>("Bounty", "MaxActiveBountyPerPlayer", 1, "How many bounties one player may hold at a time.");
			BountyArrivalRadius = ((BaseUnityPlugin)this).Config.Bind<float>("Bounty", "ArrivalRadius", 80f, "How close a hunter must get before the bounty's creatures are spawned, in metres. They aren't spawned until someone travels there — Valheim doesn't simulate unloaded zones, so a camp placed in advance would sit frozen.");
			BountyButtonOffset = ((BaseUnityPlugin)this).Config.Bind<string>("Bounty", "InventoryButtonOffset", "0,0", "LEGACY — superseded by Interface/MenuBarOffset. The Bounty Board button is now one of a row of menu buttons, so this nudges the WHOLE row. Left in place because it still works: if you had already dialled a value in here it is honoured and MenuBarOffset is ignored. Leave it at \"0,0\" to use MenuBarOffset instead.");
			BountyRefreshHours = ((BaseUnityPlugin)this).Config.Bind<float>("Bounty", "RefreshHours", 24f, "How long an UNCLAIMED posting stays on the board before it's retired and replaced, in real hours. Accepted bounties never expire — a hunter part-way to their mark keeps it. Set to 0 to disable rotation entirely.");
			BountyEliteChance = ((BaseUnityPlugin)this).Config.Bind<float>("Bounty", "EliteChance", 0.25f, "Chance (0-1) that a newly posted bounty is an ELITE (top-tier) one. Only ever one open at a time, and only hunters ranked high enough may take it — see EliteRankTopN. The top tier is never reached from a biome alone, so this is the only way it appears.");
			BountyEliteRankTopN = ((BaseUnityPlugin)this).Config.Bind<int>("Bounty", "EliteRankTopN", 10, "How high a player must rank on the duel OR party ladder to answer elite postings. This is the second, non-Valcoin reason to compete: rank buys ACCESS here, where the coin roll only changes a chance. 0 disables the gate (anyone may take them).");
			_harmony = new Harmony("com.lostscrollsii");
			_harmony.PatchAll();
			((Component)this).gameObject.AddComponent<CompanionMapPins>();
			((Component)this).gameObject.AddComponent<CommunionRite>();
			((Component)this).gameObject.AddComponent<SealingRite>();
			((Component)this).gameObject.AddComponent<CompanionInventoryGui>();
			((Component)this).gameObject.AddComponent<ContainerPanelPositioner>();
			((Component)this).gameObject.AddComponent<TournamentClient>();
			((Component)this).gameObject.AddComponent<TournamentRegistration>();
			((Component)this).gameObject.AddComponent<BountyBoardRunner>();
			((Component)this).gameObject.AddComponent<BountyBoardPanel>();
			Log.LogInfo((object)"Lost Scrolls II v0.9.1 loaded.");
		}

		private void OnDestroy()
		{
			Harmony harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}

		private void Update()
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null) && !TextInput.IsVisible() && (!((Object)(object)Chat.instance != (Object)null) || !Chat.instance.HasFocus()) && !Console.IsVisible() && !CompanionInventoryGui.IsTyping && (!TournamentRegistration.IsOpen || Input.GetKeyDown(TournamentUiKey.Value)) && (!BountyBoardPanel.IsOpen || Input.GetKeyDown(BountyUiKey.Value)))
			{
				if (Input.GetKeyDown(BountyUiKey.Value))
				{
					BountyBoardPanel.Toggle(localPlayer);
				}
				if (Input.GetKeyDown(CommunionKey.Value))
				{
					HandleFeedInput(localPlayer);
				}
				if (CommunionRite.BlockHeld())
				{
					TryBeginCommune(localPlayer);
					TryBeginSeal(localPlayer);
				}
				if (Input.GetKeyDown(ChoreAssignKey.Value))
				{
					HandleChoreAssignInput(localPlayer);
				}
				if (Input.GetKeyDown(DuelSelectKey.Value))
				{
					HandleDuelInput(localPlayer);
				}
				if (Input.GetKeyDown(PartyDuelKey.Value))
				{
					HandlePartyDuelInput(localPlayer);
				}
				if (Input.GetKeyDown(StanceCycleKey.Value))
				{
					HandleStanceCycleInput(localPlayer);
				}
				if (Input.GetKeyDown(InventoryKey.Value))
				{
					HandleInventoryInput(localPlayer);
				}
				if (Input.GetKeyDown(RankingUiKey.Value))
				{
					RankingBoard.Open();
				}
				if (Input.GetKeyDown(TournamentUiKey.Value))
				{
					TournamentRegistration.Toggle(localPlayer);
				}
			}
		}

		private void HandleInventoryInput(Player player)
		{
			GameObject hoverObject = ((Humanoid)player).GetHoverObject();
			if ((Object)(object)hoverObject == (Object)null)
			{
				return;
			}
			Character componentInParent = hoverObject.GetComponentInParent<Character>();
			DvergrCompanion dvergrCompanion = ((componentInParent != null) ? ((Component)componentInParent).GetComponent<DvergrCompanion>() : null);
			if ((Object)(object)dvergrCompanion == (Object)null)
			{
				return;
			}
			if (!dvergrCompanion.IsOwner(player))
			{
				MessageHud.instance.ShowMessage((MessageType)2, "This companion answers to another.", 0, (Sprite)null, false);
				return;
			}
			CompanionInventory companionInventory = ((Component)dvergrCompanion).GetComponent<CompanionInventory>();
			if ((Object)(object)companionInventory == (Object)null)
			{
				companionInventory = ((Component)dvergrCompanion).gameObject.AddComponent<CompanionInventory>();
			}
			CompanionInventoryGui.Open(dvergrCompanion, companionInventory);
		}

		private void HandleFeedInput(Player player)
		{
			GameObject hoverObject = ((Humanoid)player).GetHoverObject();
			if ((Object)(object)hoverObject == (Object)null)
			{
				return;
			}
			Character componentInParent = hoverObject.GetComponentInParent<Character>();
			if ((Object)(object)componentInParent == (Object)null)
			{
				return;
			}
			DvergrCompanion component = ((Component)componentInParent).GetComponent<DvergrCompanion>();
			if (!((Object)(object)component == (Object)null))
			{
				bool flag = component.IsOwner(player);
				if (MeadFeedingService.TryFeed(componentInParent, player))
				{
					MessageHud.instance.ShowMessage((MessageType)2, flag ? "Your ally drinks deep." : (component.DisplayName + " drinks deep."), 0, (Sprite)null, false);
				}
				else
				{
					MessageHud.instance.ShowMessage((MessageType)2, "You have no health mead to offer.", 0, (Sprite)null, false);
				}
			}
		}

		private void TryBeginCommune(Player player)
		{
			if ((Object)(object)CommunionRite.Instance == (Object)null || CommunionRite.Instance.IsActive)
			{
				return;
			}
			GameObject hoverObject = ((Humanoid)player).GetHoverObject();
			if (!((Object)(object)hoverObject == (Object)null))
			{
				Character componentInParent = hoverObject.GetComponentInParent<Character>();
				if (!((Object)(object)componentInParent == (Object)null) && !((Object)(object)((Component)componentInParent).GetComponent<DvergrCompanion>() != (Object)null) && CommunionService.IsSubduedDvergr(componentInParent))
				{
					CommunionRite.Instance.Begin(componentInParent, player);
				}
			}
		}

		private void TryBeginSeal(Player player)
		{
			SealingRite instance = SealingRite.Instance;
			if ((Object)(object)instance == (Object)null || instance.IsActive || ((Object)(object)CommunionRite.Instance != (Object)null && CommunionRite.Instance.IsActive))
			{
				return;
			}
			GameObject hoverObject = ((Humanoid)player).GetHoverObject();
			if (!((Object)(object)hoverObject == (Object)null))
			{
				Character componentInParent = hoverObject.GetComponentInParent<Character>();
				DvergrCompanion dvergrCompanion = (((Object)(object)componentInParent != (Object)null) ? ((Component)componentInParent).GetComponent<DvergrCompanion>() : null);
				if (!((Object)(object)dvergrCompanion == (Object)null))
				{
					instance.Begin(dvergrCompanion, player);
				}
			}
		}

		private void HandleChoreAssignInput(Player player)
		{
			//IL_029d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0337: Unknown result type (might be due to invalid IL or missing references)
			GameObject hoverObject = ((Humanoid)player).GetHoverObject();
			if ((Object)(object)hoverObject == (Object)null)
			{
				return;
			}
			Character componentInParent = hoverObject.GetComponentInParent<Character>();
			DvergrCompanion dvergrCompanion = (((Object)(object)componentInParent != (Object)null) ? ((Component)componentInParent).GetComponent<DvergrCompanion>() : null);
			if ((Object)(object)dvergrCompanion != (Object)null)
			{
				if (!dvergrCompanion.IsOwner(player))
				{
					MessageHud.instance.ShowMessage((MessageType)2, "This companion answers to another.", 0, (Sprite)null, false);
					return;
				}
				ChoreAI component = ((Component)dvergrCompanion).GetComponent<ChoreAI>();
				if ((Object)(object)component != (Object)null && component.IsAssigned)
				{
					component.Unassign();
					MessageHud.instance.ShowMessage((MessageType)2, "Ally returns to your side.", 0, (Sprite)null, false);
				}
				else
				{
					MessageHud.instance.ShowMessage((MessageType)2, "This ally has no chore to leave.", 0, (Sprite)null, false);
				}
				return;
			}
			Smelter componentInParent2 = hoverObject.GetComponentInParent<Smelter>();
			Fermenter val = (((Object)(object)componentInParent2 == (Object)null) ? hoverObject.GetComponentInParent<Fermenter>() : null);
			CookingStation val2 = (((Object)(object)componentInParent2 == (Object)null && (Object)(object)val == (Object)null) ? hoverObject.GetComponentInParent<CookingStation>() : null);
			Pickable val3 = (((Object)(object)componentInParent2 == (Object)null && (Object)(object)val == (Object)null && (Object)(object)val2 == (Object)null) ? hoverObject.GetComponentInParent<Pickable>() : null);
			ItemStand val4 = null;
			Character val5 = null;
			Container val6 = null;
			if ((Object)(object)componentInParent2 == (Object)null && (Object)(object)val == (Object)null && (Object)(object)val2 == (Object)null && (Object)(object)val3 == (Object)null)
			{
				ItemStand componentInParent3 = hoverObject.GetComponentInParent<ItemStand>();
				if ((Object)(object)componentInParent3 != (Object)null && componentInParent3.HaveAttachment() && componentInParent3.GetAttachedItem() == "Cultivator")
				{
					val4 = componentInParent3;
				}
				if ((Object)(object)val4 == (Object)null)
				{
					Character componentInParent4 = hoverObject.GetComponentInParent<Character>();
					if ((Object)(object)componentInParent4 != (Object)null && componentInParent4.IsTamed() && (Object)(object)((Component)componentInParent4).GetComponent<DvergrCompanion>() == (Object)null)
					{
						val5 = componentInParent4;
					}
					if ((Object)(object)val5 == (Object)null)
					{
						val6 = hoverObject.GetComponentInParent<Container>();
					}
				}
			}
			if ((Object)(object)componentInParent2 == (Object)null && (Object)(object)val == (Object)null && (Object)(object)val2 == (Object)null && (Object)(object)val3 == (Object)null && (Object)(object)val4 == (Object)null && (Object)(object)val5 == (Object)null && (Object)(object)val6 == (Object)null)
			{
				return;
			}
			ChoreAI choreAI = ChoreAI.ClaimantOf(((Object)(object)componentInParent2 != (Object)null) ? ((Component)componentInParent2).gameObject : (((Object)(object)val != (Object)null) ? ((Component)val).gameObject : (((Object)(object)val2 != (Object)null) ? ((Component)val2).gameObject : (((Object)(object)val3 != (Object)null) ? ((Component)val3).gameObject : (((Object)(object)val4 != (Object)null) ? ((Component)val4).gameObject : (((Object)(object)val5 != (Object)null) ? ((Component)val5).gameObject : (((Object)(object)val6 != (Object)null) ? ((Component)val6).gameObject : null)))))));
			if ((Object)(object)choreAI == (Object)null && (Object)(object)val5 != (Object)null)
			{
				choreAI = ChoreAI.FeederCovering(((Component)val5).transform.position);
			}
			if ((Object)(object)choreAI != (Object)null)
			{
				DvergrCompanion component2 = ((Component)choreAI).GetComponent<DvergrCompanion>();
				if ((Object)(object)component2 != (Object)null && component2.IsOwner(player))
				{
					choreAI.Unassign();
					MessageHud.instance.ShowMessage((MessageType)2, "Ally returns to your side.", 0, (Sprite)null, false);
				}
				else
				{
					MessageHud.instance.ShowMessage((MessageType)2, choreAI.WorkerName + " is already working here.", 0, (Sprite)null, false);
				}
				return;
			}
			DvergrCaste? requiredCaste = (((Object)(object)componentInParent2 != (Object)null) ? ChoreRules.RequiredCaste(componentInParent2) : new DvergrCaste?((!((Object)(object)val6 != (Object)null)) ? DvergrCaste.SupportMage : DvergrCaste.Rogue));
			DvergrCompanion dvergrCompanion2 = FindNearestRecruitedCompanion(((Component)player).transform.position, ChoreAssignRadius.Value, requiredCaste, player, freeOnly: true);
			if ((Object)(object)dvergrCompanion2 == (Object)null)
			{
				string text = (requiredCaste.HasValue ? ("Only your own free " + ChoreRules.DisplayName(requiredCaste.Value) + " can do this — none nearby.") : "No free ally of yours nearby to assign.");
				MessageHud.instance.ShowMessage((MessageType)2, text, 0, (Sprite)null, false);
				return;
			}
			ChoreAI choreAI2 = ((Component)dvergrCompanion2).GetComponent<ChoreAI>();
			if ((Object)(object)choreAI2 == (Object)null)
			{
				choreAI2 = ((Component)dvergrCompanion2).gameObject.AddComponent<ChoreAI>();
			}
			if ((Object)(object)componentInParent2 != (Object)null)
			{
				choreAI2.AssignToSmelter(componentInParent2);
				MessageHud.instance.ShowMessage((MessageType)2, "Ally tends the station.", 0, (Sprite)null, false);
			}
			else if ((Object)(object)val != (Object)null)
			{
				choreAI2.AssignToFermenter(val);
				MessageHud.instance.ShowMessage((MessageType)2, "Ally tends the brew.", 0, (Sprite)null, false);
			}
			else if ((Object)(object)val2 != (Object)null)
			{
				choreAI2.AssignToCooking(val2);
				MessageHud.instance.ShowMessage((MessageType)2, "Ally tends the cookfire.", 0, (Sprite)null, false);
			}
			else if ((Object)(object)val3 != (Object)null || (Object)(object)val4 != (Object)null)
			{
				choreAI2.AssignToFarm(((Object)(object)val3 != (Object)null) ? ((Component)val3).gameObject : ((Component)val4).gameObject);
				MessageHud.instance.ShowMessage((MessageType)2, "Ally tends the field.", 0, (Sprite)null, false);
			}
			else if ((Object)(object)val5 != (Object)null)
			{
				choreAI2.AssignToFeedAnimals(((Component)val5).gameObject);
				MessageHud.instance.ShowMessage((MessageType)2, "Ally tends the animals.", 0, (Sprite)null, false);
			}
			else
			{
				choreAI2.AssignToHaul(val6);
				MessageHud.instance.ShowMessage((MessageType)2, "Ally hauls to this chest.", 0, (Sprite)null, false);
			}
		}

		private void HandleDuelInput(Player player)
		{
			GameObject hoverObject = ((Humanoid)player).GetHoverObject();
			if (!((Object)(object)hoverObject == (Object)null))
			{
				Character componentInParent = hoverObject.GetComponentInParent<Character>();
				DvergrCompanion dvergrCompanion = (((Object)(object)componentInParent != (Object)null) ? ((Component)componentInParent).GetComponent<DvergrCompanion>() : null);
				if ((Object)(object)dvergrCompanion == (Object)null)
				{
					MessageHud.instance.ShowMessage((MessageType)2, "That is not an ally you can pit in a duel.", 0, (Sprite)null, false);
				}
				else if (!dvergrCompanion.IsOwner(player))
				{
					MessageHud.instance.ShowMessage((MessageType)2, "Only its owner can send this companion to duel.", 0, (Sprite)null, false);
				}
				else if (dvergrCompanion.DuelMode)
				{
					dvergrCompanion.ExitDuelMode(DvergrCompanion.DuelExitReason.OwnerStopped);
				}
				else if (!dvergrCompanion.EnterDuelMode())
				{
					MessageHud.instance.ShowMessage((MessageType)2, "This companion cannot duel right now — unassign its chore first.", 0, (Sprite)null, false);
				}
			}
		}

		private void HandlePartyDuelInput(Player player)
		{
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			GameObject hoverObject = ((Humanoid)player).GetHoverObject();
			if ((Object)(object)hoverObject == (Object)null)
			{
				return;
			}
			Character componentInParent = hoverObject.GetComponentInParent<Character>();
			DvergrCompanion dvergrCompanion = (((Object)(object)componentInParent != (Object)null) ? ((Component)componentInParent).GetComponent<DvergrCompanion>() : null);
			if ((Object)(object)dvergrCompanion == (Object)null)
			{
				MessageHud.instance.ShowMessage((MessageType)2, "That is not an ally you can send to a party duel.", 0, (Sprite)null, false);
				return;
			}
			if (!dvergrCompanion.IsOwner(player))
			{
				MessageHud.instance.ShowMessage((MessageType)2, "Only its owner can send this companion to duel.", 0, (Sprite)null, false);
				return;
			}
			long playerID = player.GetPlayerID();
			bool flag = false;
			foreach (DvergrCompanion item in DvergrCompanion.All)
			{
				if ((Object)(object)item != (Object)null && item.OwnerId == playerID && item.PartyDuelMode)
				{
					flag = true;
					break;
				}
			}
			if (flag)
			{
				int num = 0;
				foreach (DvergrCompanion item2 in DvergrCompanion.All)
				{
					if ((Object)(object)item2 != (Object)null && item2.OwnerId == playerID && item2.PartyDuelMode)
					{
						item2.ExitPartyDuelMode(DvergrCompanion.DuelExitReason.OwnerStopped);
						num++;
					}
				}
				MessageHud.instance.ShowMessage((MessageType)2, $"Your party ({num}) stands down.", 0, (Sprite)null, false);
				return;
			}
			List<Character> list = new List<Character>();
			Character.GetCharactersInRange(((Component)player).transform.position, 25f, list);
			List<DvergrCompanion> list2 = new List<DvergrCompanion>();
			foreach (Character item3 in list)
			{
				DvergrCompanion component = ((Component)item3).GetComponent<DvergrCompanion>();
				if (!((Object)(object)component == (Object)null) && component.OwnerId == playerID && component.Stance == CompanionStance.Follow)
				{
					ChoreAI component2 = ((Component)item3).GetComponent<ChoreAI>();
					if ((component2 == null || !component2.IsAssigned) && !component.DuelMode && !component.IsFeral)
					{
						list2.Add(component);
					}
				}
			}
			if (list2.Count == 0)
			{
				MessageHud.instance.ShowMessage((MessageType)2, "No free Follow-stance allies of yours nearby to form a party.", 0, (Sprite)null, false);
				return;
			}
			list2.Sort((DvergrCompanion a, DvergrCompanion b) => Vector3.Distance(((Component)player).transform.position, ((Component)a).transform.position).CompareTo(Vector3.Distance(((Component)player).transform.position, ((Component)b).transform.position)));
			int num2 = Mathf.Max(1, MaxPartySize.Value);
			int num3 = 0;
			foreach (DvergrCompanion item4 in list2)
			{
				if (num3 >= num2)
				{
					break;
				}
				if (item4.EnterPartyDuelMode())
				{
					num3++;
				}
			}
			MessageHud.instance.ShowMessage((MessageType)2, $"Your party ({num3}) squares up — waiting for a rival party.", 0, (Sprite)null, false);
		}

		private void HandleStanceCycleInput(Player player)
		{
			GameObject hoverObject = ((Humanoid)player).GetHoverObject();
			if ((Object)(object)hoverObject == (Object)null)
			{
				return;
			}
			Character componentInParent = hoverObject.GetComponentInParent<Character>();
			DvergrCompanion dvergrCompanion = ((componentInParent != null) ? ((Component)componentInParent).GetComponent<DvergrCompanion>() : null);
			if ((Object)(object)dvergrCompanion == (Object)null)
			{
				return;
			}
			if (!dvergrCompanion.IsOwner(player))
			{
				MessageHud.instance.ShowMessage((MessageType)2, "This companion answers to another.", 0, (Sprite)null, false);
				return;
			}
			ChoreAI component = ((Component)componentInParent).GetComponent<ChoreAI>();
			if ((component != null && component.IsAssigned) || dvergrCompanion.InAnyDuelMode)
			{
				MessageHud.instance.ShowMessage((MessageType)2, "Ally is busy — unassign it first.", 0, (Sprite)null, false);
				return;
			}
			CompanionStance companionStance = ((dvergrCompanion.Stance == CompanionStance.Follow) ? CompanionStance.Guard : ((dvergrCompanion.Stance == CompanionStance.Guard) ? CompanionStance.Standby : CompanionStance.Follow));
			dvergrCompanion.SetStance(companionStance, ((Component)player).gameObject);
			MessageHud.instance.ShowMessage((MessageType)2, "Ally stance: " + companionStance switch
			{
				CompanionStance.Guard => "Guard", 
				CompanionStance.Follow => "Follow", 
				_ => "Standby", 
			} + ".", 0, (Sprite)null, false);
		}

		private static DvergrCompanion FindNearestRecruitedCompanion(Vector3 origin, float radius, DvergrCaste? requiredCaste = null, Player owner = null, bool freeOnly = false)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			List<Character> list = new List<Character>();
			Character.GetCharactersInRange(origin, radius, list);
			DvergrCompanion result = null;
			float num = float.MaxValue;
			foreach (Character item in list)
			{
				DvergrCompanion component = ((Component)item).GetComponent<DvergrCompanion>();
				if ((Object)(object)component == (Object)null || (requiredCaste.HasValue && component.Caste != requiredCaste.Value) || ((Object)(object)owner != (Object)null && !component.IsOwner(owner)))
				{
					continue;
				}
				if (freeOnly)
				{
					ChoreAI component2 = ((Component)item).GetComponent<ChoreAI>();
					if (component2 != null && component2.IsAssigned)
					{
						continue;
					}
				}
				float num2 = Vector3.Distance(origin, ((Component)item).transform.position);
				if (num2 < num)
				{
					num = num2;
					result = component;
				}
			}
			return result;
		}
	}
}
namespace LostScrollsII.Ranking
{
	public static class CompetitiveJson
	{
		private class Writer
		{
			private readonly StringBuilder _sb = new StringBuilder(256);

			private readonly bool _pretty;

			private int _depth;

			private bool _needComma;

			public Writer(bool pretty)
			{
				_pretty = pretty;
			}

			public void BeginObj()
			{
				Sep();
				_sb.Append('{');
				_depth++;
				_needComma = false;
			}

			public void EndObj()
			{
				_depth--;
				NewlineIndent();
				_sb.Append('}');
				_needComma = true;
			}

			public void BeginArr()
			{
				_sb.Append('[');
				_depth++;
				_needComma = false;
			}

			public void EndArr()
			{
				_depth--;
				NewlineIndent();
				_sb.Append(']');
				_needComma = true;
			}

			public void Key(string k)
			{
				Sep();
				_sb.Append('"').Append(k).Append("\":");
				if (_pretty)
				{
					_sb.Append(' ');
				}
				_needComma = false;
			}

			public void Field(string k, string v)
			{
				Key(k);
				WriteString(v);
				_needComma = true;
			}

			public void Field(string k, int v)
			{
				Key(k);
				_sb.Append(v.ToString(CultureInfo.InvariantCulture));
				_needComma = true;
			}

			public void Field(string k, long v)
			{
				Key(k);
				_sb.Append(v.ToString(CultureInfo.InvariantCulture));
				_needComma = true;
			}

			public void Field(string k, bool v)
			{
				Key(k);
				_sb.Append(v ? "true" : "false");
				_needComma = true;
			}

			public void Field(string k, float v)
			{
				Key(k);
				_sb.Append(v.ToString("R", CultureInfo.InvariantCulture));
				_needComma = true;
			}

			public void ArrString(string v)
			{
				Sep();
				WriteString(v);
				_needComma = true;
			}

			private void Sep()
			{
				if (_needComma)
				{
					_sb.Append(',');
				}
				NewlineIndent();
			}

			private void NewlineIndent()
			{
				if (_pretty && _depth != 0)
				{
					_sb.Append('\n').Append(' ', _depth * 4);
				}
			}

			private void WriteString(string v)
			{
				_sb.Append('"');
				string text = v ?? string.Empty;
				foreach (char c in text)
				{
					switch (c)
					{
					case '"':
						_sb.Append("\\\"");
						continue;
					case '\\':
						_sb.Append("\\\\");
						continue;
					case '\n':
						_sb.Append("\\n");
						continue;
					case '\r':
						_sb.Append("\\r");
						continue;
					case '\t':
						_sb.Append("\\t");
						continue;
					}
					if (c < ' ')
					{
						StringBuilder stringBuilder = _sb.Append("\\u");
						int num = c;
						stringBuilder.Append(num.ToString("x4"));
					}
					else
					{
						_sb.Append(c);
					}
				}
				_sb.Append('"');
			}

			public override string ToString()
			{
				return _sb.ToString();
			}
		}

		public static string Write(LeaderboardData d, bool pretty = false)
		{
			d = d ?? new LeaderboardData();
			Writer writer = new Writer(pretty);
			writer.BeginObj();
			writer.Field("seasonId", d.seasonId);
			writer.Key("companions");
			writer.BeginArr();
			foreach (CompanionRecord item in d.companions ?? new List<CompanionRecord>())
			{
				WriteCompanion(writer, item);
			}
			writer.EndArr();
			writer.Key("parties");
			writer.BeginArr();
			foreach (PartyRecord item2 in d.parties ?? new List<PartyRecord>())
			{
				WriteParty(writer, item2);
			}
			writer.EndArr();
			writer.EndObj();
			return writer.ToString();
		}

		public static string Write(TournamentBook b, bool pretty = false)
		{
			b = b ?? new TournamentBook();
			Writer writer = new Writer(pretty);
			writer.BeginObj();
			writer.Key("tournaments");
			writer.BeginArr();
			foreach (TournamentState item in b.tournaments ?? new List<TournamentState>())
			{
				if (item != null)
				{
					WriteTournamentObj(writer, item);
				}
			}
			writer.EndArr();
			writer.EndObj();
			return writer.ToString();
		}

		public static TournamentBook ReadTournamentBook(string json)
		{
			TournamentBook tournamentBook = new TournamentBook();
			if (!(Parse(json) is Dictionary<string, object> dictionary))
			{
				return tournamentBook;
			}
			if (dictionary.ContainsKey("tournaments"))
			{
				foreach (object item in Arr(dictionary, "tournaments"))
				{
					if (item is Dictionary<string, object> root)
					{
						tournamentBook.tournaments.Add(ReadTournamentObj(root));
					}
				}
				return tournamentBook;
			}
			TournamentState tournamentState = ReadTournamentObj(dictionary);
			tournamentState.key = "";
			tournamentBook.tournaments.Add(tournamentState);
			return tournamentBook;
		}

		public static string Write(TournamentState s, bool pretty = false)
		{
			Writer writer = new Writer(pretty);
			WriteTournamentObj(writer, s ?? new TournamentState());
			return writer.ToString();
		}

		private static void WriteTournamentObj(Writer w, TournamentState s)
		{
			w.BeginObj();
			w.Field("key", s.key);
			w.Field("currency", s.currency);
			w.Field("entryFee", s.entryFee);
			w.Field("prize", s.prize);
			w.Field("hostId", s.hostId);
			w.Field("hostName", s.hostName);
			w.Field("openedTicks", s.openedTicks);
			w.Field("hostCredit", s.hostCredit);
			w.Field("completedTicks", s.completedTicks);
			w.Field("active", s.active);
			w.Field("mode", s.mode);
			w.Field("phase", s.phase);
			w.Field("size", s.size);
			w.Field("bracketSize", s.bracketSize);
			w.Field("currentRound", s.currentRound);
			w.Field("championId", s.championId);
			w.Field("championLabel", s.championLabel);
			w.Field("seasonId", s.seasonId);
			w.Field("eliminationType", s.eliminationType);
			w.Field("totalRounds", s.totalRounds);
			w.Key("entrants");
			w.BeginArr();
			foreach (TournamentEntrant item in s.entrants ?? new List<TournamentEntrant>())
			{
				WriteEntrant(w, item);
			}
			w.EndArr();
			w.Key("matches");
			w.BeginArr();
			foreach (TournamentMatch item2 in s.matches ?? new List<TournamentMatch>())
			{
				WriteMatch(w, item2);
			}
			w.EndArr();
			w.EndObj();
		}

		public static string Write(BountyLadderData d, bool pretty = false)
		{
			d = d ?? new BountyLadderData();
			Writer writer = new Writer(pretty);
			writer.BeginObj();
			writer.Field("seasonId", d.seasonId);
			writer.Key("hunters");
			writer.BeginArr();
			foreach (BountyHunterRecord item in d.hunters ?? new List<BountyHunterRecord>())
			{
				if (item != null)
				{
					writer.BeginObj();
					writer.Field("ownerId", item.ownerId);
					writer.Field("ownerName", item.ownerName);
					writer.Field("points", item.points);
					writer.Field("kills", item.kills);
					writer.Field("communes", item.communes);
					writer.Field("bestTier", item.bestTier);
					writer.Field("lastResolvedTicks", item.lastResolvedTicks);
					writer.Field("seasonId", item.seasonId);
					writer.EndObj();
				}
			}
			writer.EndArr();
			writer.EndObj();
			return writer.ToString();
		}

		public static BountyLadderData ReadBountyLadder(string json)
		{
			Dictionary<string, object> dictionary = Parse(json) as Dictionary<string, object>;
			BountyLadderData bountyLadderData = new BountyLadderData();
			if (dictionary == null)
			{
				return bountyLadderData;
			}
			bountyLadderData.seasonId = I(dictionary, "seasonId", bountyLadderData.seasonId);
			foreach (object item in Arr(dictionary, "hunters"))
			{
				if (item is Dictionary<string, object> d)
				{
					bountyLadderData.hunters.Add(new BountyHunterRecord
					{
						ownerId = L(d, "ownerId", 0L),
						ownerName = S(d, "ownerName"),
						points = I(d, "points"),
						kills = I(d, "kills"),
						communes = I(d, "communes"),
						bestTier = I(d, "bestTier"),
						lastResolvedTicks = L(d, "lastResolvedTicks", 0L),
						seasonId = I(d, "seasonId", 1)
					});
				}
			}
			return bountyLadderData;
		}

		public static string Write(BountyBoardData d, bool pretty = false)
		{
			d = d ?? new BountyBoardData();
			Writer writer = new Writer(pretty);
			writer.BeginObj();
			writer.Key("postings");
			writer.BeginArr();
			foreach (BountyPosting item in d.postings ?? new List<BountyPosting>())
			{
				if (item != null)
				{
					writer.BeginObj();
					writer.Field("id", item.id);
					writer.Field("tier", item.tier);
					writer.Field("biome", item.biome);
					writer.Field("x", item.x);
					writer.Field("y", item.y);
					writer.Field("z", item.z);
					writer.Field("acceptedBy", item.acceptedBy);
					writer.Field("acceptedByName", item.acceptedByName);
					writer.Field("spawned", item.spawned);
					writer.Field("postedTicks", item.postedTicks);
					writer.Field("tutorial", item.tutorial);
					writer.EndObj();
				}
			}
			writer.EndArr();
			writer.EndObj();
			return writer.ToString();
		}

		public static BountyBoardData ReadBountyBoard(string json)
		{
			Dictionary<string, object> dictionary = Parse(json) as Dictionary<string, object>;
			BountyBoardData bountyBoardData = new BountyBoardData();
			if (dictionary == null)
			{
				return bountyBoardData;
			}
			foreach (object item in Arr(dictionary, "postings"))
			{
				if (item is Dictionary<string, object> d)
				{
					bountyBoardData.postings.Add(new BountyPosting
					{
						id = S(d, "id"),
						tier = I(d, "tier", 1),
						biome = I(d, "biome"),
						x = F(d, "x"),
						y = F(d, "y"),
						z = F(d, "z"),
						acceptedBy = L(d, "acceptedBy", 0L),
						acceptedByName = S(d, "acceptedByName"),
						spawned = B(d, "spawned"),
						postedTicks = L(d, "postedTicks", 0L),
						tutorial = B(d, "tutorial")
					});
				}
			}
			return bountyBoardData;
		}

		public static string Write(ChampionsData d, bool pretty = false)
		{
			d = d ?? new ChampionsData();
			Writer writer = new Writer(pretty);
			writer.BeginObj();
			writer.Key("champions");
			writer.BeginArr();
			foreach (ChampionRecord item in d.champions ?? new List<ChampionRecord>())
			{
				writer.BeginObj();
				writer.Field("mode", item.mode);
				writer.Field("championLabel", item.championLabel);
				writer.Field("ownerName", item.ownerName);
				writer.Field("bracketSize", item.bracketSize);
				writer.Field("seasonId", item.seasonId);
				writer.Field("dateTicks", item.dateTicks);
				writer.EndObj();
			}
			writer.EndArr();
			writer.EndObj();
			return writer.ToString();
		}

		private static void WriteCompanion(Writer w, CompanionRecord c)
		{
			w.BeginObj();
			w.Field("companionId", c.companionId);
			w.Field("ownerId", c.ownerId);
			w.Field("ownerName", c.ownerName);
			w.Field("companionName", c.companionName);
			w.Field("caste", c.caste);
			w.Field("wins", c.wins);
			w.Field("losses", c.losses);
			w.Field("winStreak", c.winStreak);
			w.Field("bestStreak", c.bestStreak);
			w.Field("rating", c.rating);
			w.Field("lastMatchTicks", c.lastMatchTicks);
			w.Field("seasonId", c.seasonId);
			w.EndObj();
		}

		private static void WriteParty(Writer w, PartyRecord p)
		{
			w.BeginObj();
			w.Field("ownerId", p.ownerId);
			w.Field("ownerName", p.ownerName);
			w.Field("partyName", p.partyName);
			w.Field("wins", p.wins);
			w.Field("losses", p.losses);
			w.Field("rating", p.rating);
			w.Field("bestTeamSize", p.bestTeamSize);
			w.Field("lastMatchTicks", p.lastMatchTicks);
			w.Field("seasonId", p.seasonId);
			w.Key("memberSnapshot");
			w.BeginArr();
			foreach (PartyMemberSnap item in p.memberSnapshot ?? new List<PartyMemberSnap>())
			{
				w.BeginObj();
				w.Field("companionId", item.companionId);
				w.Field("caste", item.caste);
				w.Field("level", item.level);
				w.EndObj();
			}
			w.EndArr();
			w.EndObj();
		}

		private static void WriteEntrant(Writer w, TournamentEntrant e)
		{
			w.BeginObj();
			w.Field("entrantId", e.entrantId);
			w.Field("ownerId", e.ownerId);
			w.Field("ownerName", e.ownerName);
			w.Field("label", e.label);
			w.Field("caste", e.caste);
			w.Field("seedRating", e.seedRating);
			w.Field("eliminated", e.eliminated);
			w.Field("level", e.level);
			w.Field("losses", e.losses);
			w.Field("wins", e.wins);
			w.Field("totemPayload", e.totemPayload);
			w.Field("feePaid", e.feePaid);
			w.Key("teamPayloads");
			w.BeginArr();
			foreach (string item in e.teamPayloads ?? new List<string>())
			{
				w.ArrString(item);
			}
			w.EndArr();
			w.EndObj();
		}

		private static void WriteMatch(Writer w, TournamentMatch m)
		{
			w.BeginObj();
			w.Field("round", m.round);
			w.Field("aId", m.aId);
			w.Field("bId", m.bId);
			w.Field("aLabel", m.aLabel);
			w.Field("bLabel", m.bLabel);
			w.Field("aLevel", m.aLevel);
			w.Field("bLevel", m.bLevel);
			w.Field("winnerId", m.winnerId);
			w.Field("bracket", m.bracket);
			w.Field("aReady", m.aReady);
			w.Field("bReady", m.bReady);
			w.Field("activated", m.activated);
			w.EndObj();
		}

		public static LeaderboardData ReadLeaderboard(string json)
		{
			Dictionary<string, object> dictionary = Parse(json) as Dictionary<string, object>;
			LeaderboardData leaderboardData = new LeaderboardData();
			if (dictionary == null)
			{
				return leaderboardData;
			}
			leaderboardData.seasonId = I(dictionary, "seasonId", leaderboardData.seasonId);
			foreach (object item in Arr(dictionary, "companions"))
			{
				if (item is Dictionary<string, object> d)
				{
					leaderboardData.companions.Add(new CompanionRecord
					{
						companionId = S(d, "companionId"),
						ownerId = L(d, "ownerId", 0L),
						ownerName = S(d, "ownerName"),
						companionName = S(d, "companionName"),
						caste = I(d, "caste"),
						wins = I(d, "wins"),
						losses = I(d, "losses"),
						winStreak = I(d, "winStreak"),
						bestStreak = I(d, "bestStreak"),
						rating = I(d, "rating", 1000),
						lastMatchTicks = L(d, "lastMatchTicks", 0L),
						seasonId = I(d, "seasonId", 1)
					});
				}
			}
			foreach (object item2 in Arr(dictionary, "parties"))
			{
				if (!(item2 is Dictionary<string, object> d2))
				{
					continue;
				}
				PartyRecord partyRecord = new PartyRecord
				{
					ownerId = L(d2, "ownerId", 0L),
					ownerName = S(d2, "ownerName"),
					partyName = S(d2, "partyName"),
					wins = I(d2, "wins"),
					losses = I(d2, "losses"),
					rating = I(d2, "rating", 1000),
					bestTeamSize = I(d2, "bestTeamSize"),
					lastMatchTicks = L(d2, "lastMatchTicks", 0L),
					seasonId = I(d2, "seasonId", 1)
				};
				foreach (object item3 in Arr(d2, "memberSnapshot"))
				{
					if (item3 is Dictionary<string, object> d3)
					{
						partyRecord.memberSnapshot.Add(new PartyMemberSnap
						{
							companionId = S(d3, "companionId"),
							caste = I(d3, "caste"),
							level = I(d3, "level")
						});
					}
				}
				leaderboardData.parties.Add(partyRecord);
			}
			return leaderboardData;
		}

		public static TournamentState ReadTournament(string json)
		{
			if (Parse(json) is Dictionary<string, object> root)
			{
				return ReadTournamentObj(root);
			}
			return new TournamentState();
		}

		private static TournamentState ReadTournamentObj(Dictionary<string, object> root)
		{
			TournamentState tournamentState = new TournamentState();
			if (root == null)
			{
				return tournamentState;
			}
			tournamentState.key = S(root, "key");
			tournamentState.currency = S(root, "currency");
			tournamentState.entryFee = I(root, "entryFee");
			tournamentState.prize = I(root, "prize");
			tournamentState.hostId = L(root, "hostId", 0L);
			tournamentState.hostName = S(root, "hostName");
			tournamentState.openedTicks = L(root, "openedTicks", 0L);
			tournamentState.hostCredit = I(root, "hostCredit");
			tournamentState.completedTicks = L(root, "completedTicks", 0L);
			tournamentState.active = B(root, "active");
			tournamentState.mode = S(root, "mode", tournamentState.mode);
			tournamentState.phase = S(root, "phase", tournamentState.phase);
			tournamentState.size = I(root, "size");
			tournamentState.bracketSize = I(root, "bracketSize");
			tournamentState.currentRound = I(root, "currentRound");
			tournamentState.championId = S(root, "championId");
			tournamentState.championLabel = S(root, "championLabel");
			tournamentState.seasonId = I(root, "seasonId", 1);
			tournamentState.eliminationType = S(root, "eliminationType", tournamentState.eliminationType);
			tournamentState.totalRounds = I(root, "totalRounds");
			foreach (object item2 in Arr(root, "entrants"))
			{
				if (!(item2 is Dictionary<string, object> d))
				{
					continue;
				}
				TournamentEntrant tournamentEntrant = new TournamentEntrant
				{
					entrantId = S(d, "entrantId"),
					ownerId = L(d, "ownerId", 0L),
					ownerName = S(d, "ownerName"),
					label = S(d, "label"),
					caste = I(d, "caste"),
					seedRating = I(d, "seedRating"),
					eliminated = B(d, "eliminated"),
					level = I(d, "level"),
					losses = I(d, "losses"),
					wins = I(d, "wins"),
					totemPayload = S(d, "totemPayload"),
					feePaid = I(d, "feePaid")
				};
				foreach (object item3 in Arr(d, "teamPayloads"))
				{
					if (item3 is string item)
					{
						tournamentEntrant.teamPayloads.Add(item);
					}
				}
				tournamentState.entrants.Add(tournamentEntrant);
			}
			foreach (object item4 in Arr(root, "matches"))
			{
				if (item4 is Dictionary<string, object> d2)
				{
					tournamentState.matches.Add(new TournamentMatch
					{
						round = I(d2, "round"),
						aId = S(d2, "aId"),
						bId = S(d2, "bId"),
						aLabel = S(d2, "aLabel"),
						bLabel = S(d2, "bLabel"),
						aLevel = I(d2, "aLevel"),
						bLevel = I(d2, "bLevel"),
						winnerId = S(d2, "winnerId"),
						bracket = S(d2, "bracket", "W"),
						aReady = B(d2, "aReady"),
						bReady = B(d2, "bReady"),
						activated = B(d2, "activated")
					});
				}
			}
			return tournamentState;
		}

		public static string Write(DuelInviteBoard b, bool pretty = false)
		{
			b = b ?? new DuelInviteBoard();
			Writer writer = new Writer(pretty);
			writer.BeginObj();
			writer.Key("invites");
			writer.BeginArr();
			foreach (DuelInvite item in b.invites ?? new List<DuelInvite>())
			{
				if (item != null)
				{
					writer.BeginObj();
					writer.Field("id", item.id);
					writer.Field("currency", item.currency);
					writer.Field("stake", item.stake);
					writer.Field("phase", item.phase);
					writer.Field("hostId", item.hostId);
					writer.Field("hostName", item.hostName);
					writer.Field("hostEntrantId", item.hostEntrantId);
					writer.Field("hostLabel", item.hostLabel);
					writer.Field("hostLevel", item.hostLevel);
					writer.Field("hostCaste", item.hostCaste);
					writer.Field("hostPayload", item.hostPayload);
					writer.Field("hostReady", item.hostReady);
					writer.Field("oppId", item.oppId);
					writer.Field("oppName", item.oppName);
					writer.Field("oppEntrantId", item.oppEntrantId);
					writer.Field("oppLabel", item.oppLabel);
					writer.Field("oppLevel", item.oppLevel);
					writer.Field("oppCaste", item.oppCaste);
					writer.Field("oppPayload", item.oppPayload);
					writer.Field("oppReady", item.oppReady);
					writer.Field("createdTicks", item.createdTicks);
					writer.Field("completedTicks", item.completedTicks);
					writer.EndObj();
				}
			}
			writer.EndArr();
			writer.EndObj();
			return writer.ToString();
		}

		public static DuelInviteBoard ReadInvites(string json)
		{
			DuelInviteBoard duelInviteBoard = new DuelInviteBoard();
			if (!(Parse(json) is Dictionary<string, object> d))
			{
				return duelInviteBoard;
			}
			foreach (object item in Arr(d, "invites"))
			{
				if (item is Dictionary<string, object> d2)
				{
					duelInviteBoard.invites.Add(new DuelInvite
					{
						id = S(d2, "id"),
						currency = S(d2, "currency"),
						stake = I(d2, "stake"),
						phase = S(d2, "phase", "open"),
						hostId = L(d2, "hostId", 0L),
						hostName = S(d2, "hostName"),
						hostEntrantId = S(d2, "hostEntrantId"),
						hostLabel = S(d2, "hostLabel"),
						hostLevel = I(d2, "hostLevel"),
						hostCaste = I(d2, "hostCaste"),
						hostPayload = S(d2, "hostPayload"),
						hostReady = B(d2, "hostReady"),
						oppId = L(d2, "oppId", 0L),
						oppName = S(d2, "oppName"),
						oppEntrantId = S(d2, "oppEntrantId"),
						oppLabel = S(d2, "oppLabel"),
						oppLevel = I(d2, "oppLevel"),
						oppCaste = I(d2, "oppCaste"),
						oppPayload = S(d2, "oppPayload"),
						oppReady = B(d2, "oppReady"),
						createdTicks = L(d2, "createdTicks", 0L),
						completedTicks = L(d2, "completedTicks", 0L)
					});
				}
			}
			return duelInviteBoard;
		}

		public static ChampionsData ReadChampions(string json)
		{
			Dictionary<string, object> dictionary = Parse(json) as Dictionary<string, object>;
			ChampionsData championsData = new ChampionsData();
			if (dictionary == null)
			{
				return championsData;
			}
			foreach (object item in Arr(dictionary, "champions"))
			{
				if (item is Dictionary<string, object> d)
				{
					championsData.champions.Add(new ChampionRecord
					{
						mode = S(d, "mode"),
						championLabel = S(d, "championLabel"),
						ownerName = S(d, "ownerName"),
						bracketSize = I(d, "bracketSize"),
						seasonId = I(d, "seasonId", 1),
						dateTicks = L(d, "dateTicks", 0L)
					});
				}
			}
			return championsData;
		}

		private static string S(Dictionary<string, object> d, string k, string def = "")
		{
			if (!d.TryGetValue(k, out var value) || !(value is string result))
			{
				return def;
			}
			return result;
		}

		private static int I(Dictionary<string, object> d, string k, int def = 0)
		{
			if (!d.TryGetValue(k, out var value))
			{
				return def;
			}
			if (!(value is long num))
			{
				if (!(value is double num2))
				{
					return def;
				}
				return (int)num2;
			}
			return (int)num;
		}

		private static long L(Dictionary<string, object> d, string k, long def = 0L)
		{
			if (!d.TryGetValue(k, out var value))
			{
				return def;
			}
			if (value is long)
			{
				return (long)value;
			}
			if (!(value is double num))
			{
				return def;
			}
			return (long)num;
		}

		private static bool B(Dictionary<string, object> d, string k, bool def = false)
		{
			if (d.TryGetValue(k, out var value) && value is bool)
			{
				return (bool)value;
			}
			return def;
		}

		private static float F(Dictionary<string, object> d, string k, float def = 0f)
		{
			if (!d.TryGetValue(k, out var value))
			{
				return def;
			}
			if (!(value is double num))
			{
				if (!(value is long num2))
				{
					return def;
				}
				return num2;
			}
			return (float)num;
		}

		private static List<object> Arr(Dictionary<string, object> d, string k)
		{
			if (!d.TryGetValue(k, out var value) || !(value is List<object> result))
			{
				return new List<object>();
			}
			return result;
		}

		private static object Parse(string json)
		{
			if (string.IsNullOrEmpty(json))
			{
				return null;
			}
			int i = 0;
			try
			{
				return ParseValue(json, ref i);
			}
			catch
			{
				return null;
			}
		}

		private static object ParseValue(string s, ref int i)
		{
			SkipWs(s, ref i);
			switch (s[i])
			{
			case '{':
				return ParseObject(s, ref i);
			case '[':
				return ParseArray(s, ref i);
			case '"':
				return ParseString(s, ref i);
			case 't':
				Expect(s, ref i, "true");
				return true;
			case 'f':
				Expect(s, ref i, "false");
				return false;
			case 'n':
				Expect(s, ref i, "null");
				return null;
			default:
				return ParseNumber(s, ref i);
			}
		}

		private static Dictionary<string, object> ParseObject(string s, ref int i)
		{
			Dictionary<string, object> dictionary = new Dictionary<string, object>();
			i++;
			SkipWs(s, ref i);
			if (s[i] == '}')
			{
				i++;
				return dictionary;
			}
			while (true)
			{
				SkipWs(s, ref i);
				string key = ParseString(s, ref i);
				SkipWs(s, ref i);
				if (s[i] != ':')
				{
					throw new FormatException("expected ':'");
				}
				i++;
				dictionary[key] = ParseValue(s, ref i);
				SkipWs(s, ref i);
				if (s[i] != ',')
				{
					break;
				}
				i++;
			}
			if (s[i] == '}')
			{
				i++;
				return dictionary;
			}
			throw new FormatException("expected ',' or '}'");
		}

		private static List<object> ParseArray(string s, ref int i)
		{
			List<object> list = new List<object>();
			i++;
			SkipWs(s, ref i);
			if (s[i] == ']')
			{
				i++;
				return list;
			}
			while (true)
			{
				list.Add(ParseValue(s, ref i));
				SkipWs(s, ref i);
				if (s[i] != ',')
				{
					break;
				}
				i++;
			}
			if (s[i] == ']')
			{
				i++;
				return list;
			}
			throw new FormatException("expected ',' or ']'");
		}

		private static string ParseString(string s, ref int i)
		{
			if (s[i] != '"')
			{
				throw new FormatException("expected '\"'");
			}
			i++;
			StringBuilder stringBuilder = new StringBuilder();
			while (true)
			{
				char c = s[i++];
				switch (c)
				{
				case '"':
					return stringBuilder.ToString();
				case '\\':
					switch (s[i++])
					{
					case '"':
						stringBuilder.Append('"');
						break;
					case '\\':
						stringBuilder.Append('\\');
						break;
					case '/':
						stringBuilder.Append('/');
						break;
					case 'n':
						stringBuilder.Append('\n');
						break;
					case 'r':
						stringBuilder.Append('\r');
						break;
					case 't':
						stringBuilder.Append('\t');
						break;
					case 'b':
						stringBuilder.Append('\b');
						break;
					case 'f':
						stringBuilder.Append('\f');
						break;
					case 'u':
						stringBuilder.Append((char)int.Parse(s.Substring(i, 4), NumberStyles.HexNumber, CultureInfo.InvariantCulture));
						i += 4;
						break;
					default:
						throw new FormatException("bad escape");
					}
					break;
				default:
					stringBuilder.Append(c);
					break;
				}
			}
		}

		private static object ParseNumber(string s, ref int i)
		{
			int num = i;
			while (i < s.Length && (char.IsDigit(s[i]) || s[i] == '-' || s[i] == '+' || s[i] == '.' || s[i] == 'e' || s[i] == 'E'))
			{
				i++;
			}
			string text = s.Substring(num, i - num);
			if (text.IndexOf('.') < 0 && text.IndexOf('e') < 0 && text.IndexOf('E') < 0 && long.TryParse(text, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
			{
				return result;
			}
			return double.Parse(text, CultureInfo.InvariantCulture);
		}

		private static void Expect(string s, ref int i, string word)
		{
			if (string.CompareOrdinal(s, i, word, 0, word.Length) != 0)
			{
				throw new FormatException("expected '" + word + "'");
			}
			i += word.Length;
		}

		private static void SkipWs(string s, ref int i)
		{
			while (i < s.Length && (s[i] == ' ' || s[i] == '\t' || s[i] == '\n' || s[i] == '\r'))
			{
				i++;
			}
		}
	}
	[Serializable]
	public class DuelInvite
	{
		public string id = "";

		public string currency = "";

		public int stake;

		public string phase = "open";

		public long hostId;

		public string hostName = "";

		public string hostEntrantId = "";

		public string hostLabel = "";

		public int hostLevel;

		public int hostCaste;

		public string hostPayload = "";

		public bool hostReady;

		public long oppId;

		public string oppName = "";

		public string oppEntrantId = "";

		public string oppLabel = "";

		public int oppLevel;

		public int oppCaste;

		public string oppPayload = "";

		public bool oppReady;

		public long createdTicks;

		public long completedTicks;

		public bool Involves(long ownerId)
		{
			if (ownerId != 0L)
			{
				if (hostId != ownerId)
				{
					return oppId == ownerId;
				}
				return true;
			}
			return false;
		}

		public bool HasEntrant(string entrantId)
		{
			if (!string.IsNullOrEmpty(entrantId))
			{
				if (!(hostEntrantId == entrantId))
				{
					return oppEntrantId == entrantId;
				}
				return true;
			}
			return false;
		}

		public bool IsHostEntrant(string entrantId)
		{
			if (!string.IsNullOrEmpty(entrantId))
			{
				return hostEntrantId == entrantId;
			}
			return false;
		}
	}
	[Serializable]
	public class DuelInviteBoard
	{
		public List<DuelInvite> invites = new List<DuelInvite>();

		public DuelInvite Find(string id)
		{
			if (!string.IsNullOrEmpty(id))
			{
				return invites.Find((DuelInvite i) => i != null && i.id == id);
			}
			return null;
		}

		public DuelInvite ForOwner(long ownerId)
		{
			if (ownerId != 0L)
			{
				return invites.Find((DuelInvite i) => i?.Involves(ownerId) ?? false);
			}
			return null;
		}

		public DuelInvite ForEntrant(string entrantId)
		{
			if (!string.IsNullOrEmpty(entrantId))
			{
				return invites.Find((DuelInvite i) => i?.HasEntrant(entrantId) ?? false);
			}
			return null;
		}
	}
	public static class DuelInviteService
	{
		private static DuelInviteBoard _board = new DuelInviteBoard();

		private static DuelInviteBoard _snapshot = new DuelInviteBoard();

		private const double CompletionGraceSeconds = 6.0;

		public static DuelInviteBoard Snapshot => _snapshot;

		public static IEnumerable<DuelInvite> All => (_snapshot?.invites ?? new List<DuelInvite>()).Where((DuelInvite i) => i != null);

		public static DuelInvite MineIn(long ownerId)
		{
			return _snapshot?.ForOwner(ownerId);
		}

		public static DuelInvite FindByEntrant(string entrantId)
		{
			return _snapshot?.ForEntrant(entrantId);
		}

		private static string BoardPath()
		{
			return Path.Combine(LeaderboardStore.DataDir(), "duelinvites." + LeaderboardStore.WorldTag() + ".json");
		}

		public static void LoadForCurrentWorld()
		{
			try
			{
				string path = BoardPath();
				_board = (File.Exists(path) ? (CompetitiveJson.ReadInvites(File.ReadAllText(path)) ?? new DuelInviteBoard()) : new DuelInviteBoard());
				if (_board.invites == null)
				{
					_board.invites = new List<DuelInvite>();
				}
				Plugin.Log.LogInfo((object)$"[invite] resumed {_board.invites.Count} duel invite(s).");
			}
			catch (Exception ex)
			{
				_board = new DuelInviteBoard();
				Plugin.Log.LogWarning((object)("[invite] load failed: " + ex.Message));
			}
			_snapshot = _board;
		}

		private static void Save()
		{
			try
			{
				File.WriteAllText(BoardPath(), CompetitiveJson.Write(_board, pretty: true));
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[invite] save failed: " + ex.Message));
			}
		}

		public static string SerializeSnapshot()
		{
			return CompetitiveJson.Write(_board ?? new DuelInviteBoard());
		}

		public static void ApplySnapshot(string json)
		{
			try
			{
				DuelInviteBoard duelInviteBoard = CompetitiveJson.ReadInvites(json) ?? new DuelInviteBoard();
				if (duelInviteBoard.invites == null)
				{
					duelInviteBoard.invites = new List<DuelInvite>();
				}
				_snapshot = duelInviteBoard;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[invite] snapshot apply failed: " + ex.Message));
			}
		}

		public static void Post(WagerCurrency currency, long hostId, string hostName, string entrantId, string label, int level, int caste, string payload, int clientPaidCoins, Action<bool, string> done)
		{
			if (!WagerService.IsAvailable(currency, out var reason))
			{
				done?.Invoke(arg1: false, reason);
				return;
			}
			if (string.IsNullOrEmpty(entrantId))
			{
				done?.Invoke(arg1: false, "That totem has no ladder identity and can't be staked.");
				return;
			}
			if (string.IsNullOrEmpty(payload))
			{
				done?.Invoke(arg1: false, "No companion totem was locked in.");
				return;
			}
			DuelInvite duelInvite = _board.ForOwner(hostId);
			if (duelInvite != null)
			{
				done?.Invoke(arg1: false, (duelInvite.hostId == hostId) ? "You already have a duel invite posted — withdraw it first." : "You have already accepted someone else's duel invite.");
				return;
			}
			int stake = Wager.DuelStake(currency);
			WagerService.Charge(currency, hostName, stake, "ls_duel_stake", "posted a duel invite", clientPaidCoins, delegate(bool ok, string msg)
			{
				if (!ok)
				{
					done?.Invoke(arg1: false, msg ?? "The stake could not be taken.");
				}
				else if (_board.ForOwner(hostId) != null)
				{
					WagerService.RollBackOwnCharge(currency, hostId, hostName, stake, "you were already in another duel invite");
					done?.Invoke(arg1: false, "You joined another duel invite while your stake was being processed — it is returned.");
				}
				else
				{
					DuelInvite duelInvite2 = new DuelInvite
					{
						id = Guid.NewGuid().ToString("N").Substring(0, 12),
						currency = Wager.Key(currency),
						stake = stake,
						phase = "open",
						hostId = hostId,
						hostName = (hostName ?? string.Empty),
						hostEntrantId = entrantId,
						hostLabel = (label ?? string.Empty),
						hostLevel = level,
						hostCaste = caste,
						hostPayload = payload,
						createdTicks = DateTime.UtcNow.Ticks
					};
					_board.invites.Add(duelInvite2);
					Save();
					Broadcast();
					ServerGuideBridge.AnnounceDiscord("\ud83d\udce3 **" + hostName + "** has posted a duel invite — **" + label + "**" + ((level > 0) ? $" (Lv{level})" : "") + $" · stake **{stake} {Wager.Display(currency)}**, winner takes **{stake * 2}**. " + "Accept it from the Tournament panel (F7).");
					Plugin.Log.LogInfo((object)$"[invite] {hostName} posted '{duelInvite2.id}' ({stake} {duelInvite2.currency}).");
					done?.Invoke(arg1: true, $"Duel invite posted — {stake} {Wager.Display(currency)} staked. " + "The winner takes both stakes.");
				}
			});
		}

		public static void Accept(string inviteId, long oppId, string oppName, string entrantId, string label, int level, int caste, string payload, int clientPaidCoins, Action<bool, string> done)
		{
			DuelInvite invite = _board.Find(inviteId);
			if (invite == null || invite.phase != "open")
			{
				done?.Invoke(arg1: false, "That duel invite is no longer open.");
				return;
			}
			if (invite.hostId == oppId)
			{
				done?.Invoke(arg1: false, "You cannot accept your own invite.");
				return;
			}
			if (_board.ForOwner(oppId) != null)
			{
				done?.Invoke(arg1: false, "You are already tied up in a duel invite.");
				return;
			}
			if (string.IsNullOrEmpty(entrantId))
			{
				done?.Invoke(arg1: false, "That totem has no ladder identity and can't be staked.");
				return;
			}
			if (string.IsNullOrEmpty(payload))
			{
				done?.Invoke(arg1: false, "No companion totem was locked in.");
				return;
			}
			WagerCurrency currency = Wager.Parse(invite.currency);
			if (!WagerService.IsAvailable(currency, out var reason))
			{
				done?.Invoke(arg1: false, reason);
				return;
			}
			int stake = invite.stake;
			WagerService.Charge(currency, oppName, stake, "ls_duel_stake", "accepted a duel invite", clientPaidCoins, delegate(bool ok, string msg)
			{
				if (!ok)
				{
					done?.Invoke(arg1: false, msg ?? "The stake could not be taken.");
				}
				else
				{
					invite = _board.Find(inviteId);
					if (invite == null || invite.phase != "open" || _board.ForOwner(oppId) != null)
					{
						WagerService.RollBackOwnCharge(currency, oppId, oppName, stake, "the invite was already taken");
						done?.Invoke(arg1: false, "That duel invite was taken while your stake was being processed.");
					}
					else
					{
						invite.phase = "matched";
						invite.oppId = oppId;
						invite.oppName = oppName ?? string.Empty;
						invite.oppEntrantId = entrantId;
						invite.oppLabel = label ?? string.Empty;
						invite.oppLevel = level;
						invite.oppCaste = caste;
						invite.oppPayload = payload;
						Save();
						Broadcast();
						ServerGuideBridge.AnnounceDiscord("\ud83e\udd1d **" + oppName + "** has accepted **" + invite.hostName + "**'s duel invite — " + $"**{invite.hostLabel}** vs **{label}** for **{invite.stake * 2} {Wager.Display(currency)}**. " + "The two of them choose where to fight; the duel starts once both are ready.");
						done?.Invoke(arg1: true, "Challenge accepted — meet " + invite.hostName + " and press Ready to Fight.");
					}
				}
			});
		}

		public static string SetReady(string inviteId, long ownerId)
		{
			DuelInvite duelInvite = _board.Find(inviteId);
			if (duelInvite == null)
			{
				return "that duel invite no longer exists.";
			}
			if (duelInvite.phase == "running")
			{
				return "the duel is already under way.";
			}
			if (duelInvite.phase != "matched")
			{
				return "nobody has accepted that invite yet.";
			}
			if (duelInvite.hostId == ownerId)
			{
				duelInvite.hostReady = true;
			}
			else
			{
				if (duelInvite.oppId != ownerId)
				{
					return "you are not part of that duel.";
				}
				duelInvite.oppReady = true;
			}
			if (!duelInvite.hostReady || !duelInvite.oppReady)
			{
				Save();
				Broadcast();
				string text = ((duelInvite.hostId == ownerId) ? duelInvite.oppName : duelInvite.hostName);
				return "Ready. Waiting for " + text + ".";
			}
			duelInvite.phase = "running";
			Save();
			Broadcast();
			LeaderboardSync.SummonForMatch(duelInvite.hostId, duelInvite.hostEntrantId, "1v1", duelInvite.oppEntrantId, duelInvite.oppLabel, 0, new List<string> { duelInvite.hostPayload }, "invite");
			LeaderboardSync.SummonForMatch(duelInvite.oppId, duelInvite.oppEntrantId, "1v1", duelInvite.hostEntrantId, duelInvite.hostLabel, 0, new List<string> { duelInvite.oppPayload }, "invite");
			ServerGuideBridge.AnnounceDiscord("\ud83e\udd4a **The staked duel begins:** " + duelInvite.hostLabel + " (" + duelInvite.hostName + ") vs " + $"{duelInvite.oppLabel} ({duelInvite.oppName}) — **{duelInvite.stake * 2} {Wager.Display(Wager.Parse(duelInvite.currency))}** on the line.");
			return "Both fighters are ready — the duel begins!";
		}

		public static List<KeyValuePair<long, string>> Withdraw(string inviteId, long ownerId, out string status)
		{
			List<KeyValuePair<long, string>> list = new List<KeyValuePair<long, string>>();
			status = "that duel invite no longer exists.";
			DuelInvite duelInvite = _board.Find(inviteId);
			if (duelInvite == null)
			{
				return list;
			}
			if (!duelInvite.Involves(ownerId))
			{
				status = "that is not your duel invite.";
				return list;
			}
			if (duelInvite.phase == "running")
			{
				status = "the duel is already under way — fight it out.";
				return list;
			}
			WagerCurrency currency = Wager.Parse(duelInvite.currency);
			if (duelInvite.hostId == ownerId)
			{
				if (!string.IsNullOrEmpty(duelInvite.hostPayload))
				{
					list.Add(new KeyValuePair<long, string>(duelInvite.hostId, duelInvite.hostPayload));
				}
				WagerService.Refund(currency, duelInvite.hostId, duelInvite.hostName, duelInvite.stake, "withdrew a duel invite");
				if (duelInvite.phase == "matched")
				{
					if (!string.IsNullOrEmpty(duelInvite.oppPayload))
					{
						list.Add(new KeyValuePair<long, string>(duelInvite.oppId, duelInvite.oppPayload));
					}
					WagerService.Refund(currency, duelInvite.oppId, duelInvite.oppName, duelInvite.stake, "the poster withdrew");
				}
				_board.invites.Remove(duelInvite);
				status = "Duel invite withdrawn — your stake and totem are returned.";
				ServerGuideBridge.AnnounceDiscord("\ud83d\udeab **" + duelInvite.hostName + "** withdrew their duel invite. All stakes returned.");
			}
			else
			{
				if (!string.IsNullOrEmpty(duelInvite.oppPayload))
				{
					list.Add(new KeyValuePair<long, string>(duelInvite.oppId, duelInvite.oppPayload));
				}
				WagerService.Refund(currency, duelInvite.oppId, duelInvite.oppName, duelInvite.stake, "backed out of a duel");
				string oppName = duelInvite.oppName;
				duelInvite.phase = "open";
				duelInvite.oppId = 0L;
				duelInvite.oppName = "";
				duelInvite.oppEntrantId = "";
				duelInvite.oppLabel = "";
				duelInvite.oppPayload = "";
				duelInvite.oppLevel = 0;
				duelInvite.oppCaste = 0;
				duelInvite.hostReady = false;
				duelInvite.oppReady = false;
				status = "You have backed out — your stake and totem are returned.";
				ServerGuideBridge.AnnounceDiscord("↩\ufe0f **" + oppName + "** backed out of **" + duelInvite.hostName + "**'s duel invite — it is open again.");
			}
			Save();
			Broadcast();
			return list;
		}

		public static bool NotifyDuelResult(string winnerEntrantId, string loserEntrantId)
		{
			DuelInvite duelInvite = _board.ForEntrant(winnerEntrantId);
			if (duelInvite == null || duelInvite.phase != "running")
			{
				return false;
			}
			if (!duelInvite.HasEntrant(loserEntrantId))
			{
				return false;
			}
			bool num = duelInvite.IsHostEntrant(winnerEntrantId);
			long ownerId = (num ? duelInvite.hostId : duelInvite.oppId);
			string text = (num ? duelInvite.hostName : duelInvite.oppName);
			string text2 = (num ? duelInvite.hostLabel : duelInvite.oppLabel);
			string text3 = (num ? duelInvite.oppName : duelInvite.hostName);
			string text4 = (num ? duelInvite.oppLabel : duelInvite.hostLabel);
			WagerCurrency wagerCurrency = Wager.Parse(duelInvite.currency);
			int num2 = duelInvite.stake * 2;
			WagerService.Pay(wagerCurrency, ownerId, text, num2, "ls_duel_purse", "won a staked duel");
			ServerGuideBridge.AnnounceDiscord("\ud83c\udfc6 **" + text + "** wins the staked duel — **" + text2 + "** defeats **" + text4 + "** (" + text3 + ") " + $"and takes **{num2} {Wager.Display(wagerCurrency)}**.");
			Plugin.Log.LogInfo((object)$"[invite] '{duelInvite.id}' settled: {text} takes {num2} {duelInvite.currency}.");
			duelInvite.phase = "complete";
			duelInvite.completedTicks = DateTime.UtcNow.Ticks;
			Save();
			Broadcast();
			return true;
		}

		public static bool UpdateEscrow(string entrantId, List<string> payloads)
		{
			if (payloads == null || payloads.Count == 0)
			{
				return false;
			}
			DuelInvite duelInvite = _board.ForEntrant(entrantId);
			if (duelInvite == null)
			{
				return false;
			}
			if (duelInvite.IsHostEntrant(entrantId))
			{
				duelInvite.hostPayload = payloads[0];
			}
			else
			{
				duelInvite.oppPayload = payloads[0];
			}
			Save();
			return true;
		}

		public static void Tick()
		{
			if (_board?.invites == null)
			{
				return;
			}
			bool flag = false;
			foreach (DuelInvite item in _board.invites.ToList())
			{
				Dictionary<long, List<string>> byOwner;
				if (item == null)
				{
					_board.invites.Remove(item);
					flag = true;
				}
				else if (item.phase == "complete")
				{
					if (item.completedTicks <= 0 || !((DateTime.UtcNow - new DateTime(item.completedTicks, DateTimeKind.Utc)).TotalSeconds < 6.0))
					{
						byOwner = new Dictionary<long, List<string>>();
						Add(item.hostId, item.hostPayload);
						Add(item.oppId, item.oppPayload);
						LeaderboardSync.ReturnEscrowToOwners(byOwner);
						_board.invites.Remove(item);
						flag = true;
					}
				}
				else
				{
					if (item.phase != "open")
					{
						continue;
					}
					float value = Plugin.WageredRegistrationMinutes.Value;
					if (!(value <= 0f) && item.createdTicks > 0 && !((DateTime.UtcNow - new DateTime(item.createdTicks, DateTimeKind.Utc)).TotalMinutes < (double)value))
					{
						WagerService.Refund(Wager.Parse(item.currency), item.hostId, item.hostName, item.stake, "the duel invite expired");
						if (!string.IsNullOrEmpty(item.hostPayload))
						{
							LeaderboardSync.ReturnEscrowToOwners(new Dictionary<long, List<string>> { 
							{
								item.hostId,
								new List<string> { item.hostPayload }
							} });
						}
						_board.invites.Remove(item);
						flag = true;
						ServerGuideBridge.AnnounceDiscord("⌛ **" + item.hostName + "**'s duel invite expired unanswered — stake and totem returned.");
					}
				}
				void Add(long owner, string payload)
				{
					if (owner != 0L && !string.IsNullOrEmpty(payload))
					{
						if (!byOwner.TryGetValue(owner, out var value2))
						{
							value2 = new List<string>();
							byOwner[owner] = value2;
						}
						value2.Add(payload);
					}
				}
			}
			if (flag)
			{
				Save();
				Broadcast();
			}
		}

		private static void Broadcast()
		{
			LeaderboardSync.BroadcastInvites();
		}
	}
	[Serializable]
	public class CompanionRecord
	{
		public string companionId;

		public long ownerId;

		public string ownerName;

		public string companionName;

		public int caste;

		public int wins;

		public int losses;

		public int winStreak;

		public int bestStreak;

		public int rating = 1000;

		public long lastMatchTicks;

		public int seasonId = 1;
	}
	[Serializable]
	public class PartyMemberSnap
	{
		public string companionId;

		public int caste;

		public int level;
	}
	[Serializable]
	public class PartyRecord
	{
		public long ownerId;

		public string ownerName;

		public string partyName;

		public int wins;

		public int losses;

		public int rating = 1000;

		public int bestTeamSize;

		public List<PartyMemberSnap> memberSnapshot = new List<PartyMemberSnap>();

		public long lastMatchTicks;

		public int seasonId = 1;
	}
	[Serializable]
	public class LeaderboardData
	{
		public int seasonId = 1;

		public List<CompanionRecord> companions = new List<CompanionRecord>();

		public List<PartyRecord> parties = new List<PartyRecord>();
	}
	public class PartyDuelResult
	{
		public long WinnerOwnerId;

		public string WinnerOwnerName;

		public long LoserOwnerId;

		public string LoserOwnerName;

		public int MvpCaste;

		public List<PartyMemberSnap> WinnerMembers = new List<PartyMemberSnap>();

		public List<PartyMemberSnap> LoserMembers = new List<PartyMemberSnap>();

		public string WinnerPartyName;

		public string Encode()
		{
			return string.Join("|", WinnerOwnerId.ToString(), S(WinnerOwnerName), LoserOwnerId.ToString(), S(LoserOwnerName), MvpCaste.ToString(), Members(WinnerMembers), Members(LoserMembers), S(WinnerPartyName));
			static string Members(List<PartyMemberSnap> ms)
			{
				if (ms == null || ms.Count == 0)
				{
					return string.Empty;
				}
				List<string> list = new List<string>(ms.Count);
				foreach (PartyMemberSnap m in ms)
				{
					list.Add($"{m.companionId}:{m.caste}:{m.level}");
				}
				return string.Join(",", list);
			}
			static string S(string s)
			{
				return (s ?? string.Empty).Replace('|', '/').Replace(',', ' ').Replace(':', ' ');
			}
		}

		public static PartyDuelResult Decode(string s)
		{
			if (string.IsNullOrEmpty(s))
			{
				return null;
			}
			string[] array = s.Split(new char[1] { '|' });
			if (array.Length < 7)
			{
				return null;
			}
			long.TryParse(array[0], out var result);
			long.TryParse(array[2], out var result2);
			int.TryParse(array[4], out var result3);
			return new PartyDuelResult
			{
				WinnerOwnerId = result,
				WinnerOwnerName = array[1],
				LoserOwnerId = result2,
				LoserOwnerName = array[3],
				MvpCaste = result3,
				WinnerMembers = ParseMembers(array[5]),
				LoserMembers = ParseMembers(array[6]),
				WinnerPartyName = ((array.Length > 7) ? array[7] : string.Empty)
			};
			static List<PartyMemberSnap> ParseMembers(string raw)
			{
				List<PartyMemberSnap> list = new List<PartyMemberSnap>();
				if (string.IsNullOrEmpty(raw))
				{
					return list;
				}
				string[] array2 = raw.Split(new char[1] { ',' });
				for (int i = 0; i < array2.Length; i++)
				{
					string[] array3 = array2[i].Split(new char[1] { ':' });
					if (array3.Length >= 3)
					{
						int.TryParse(array3[1], out var result4);
						int.TryParse(array3[2], out var result5);
						list.Add(new PartyMemberSnap
						{
							companionId = array3[0],
							caste = result4,
							level = result5
						});
					}
				}
				return list;
			}
		}
	}
	public class DuelResult
	{
		public string WinnerId;

		public long WinnerOwnerId;

		public string WinnerOwnerName;

		public string WinnerName;

		public int WinnerCaste;

		public string LoserId;

		public long LoserOwnerId;

		public string LoserOwnerName;

		public string LoserName;

		public int LoserCaste;

		public string Encode()
		{
			return string.Join("|", S(WinnerId), WinnerOwnerId.ToString(), S(WinnerOwnerName), S(WinnerName), WinnerCaste.ToString(), S(LoserId), LoserOwnerId.ToString(), S(LoserOwnerName), S(LoserName), LoserCaste.ToString());
			static string S(string s)
			{
				return (s ?? string.Empty).Replace('|', '/');
			}
		}

		public static DuelResult Decode(string s)
		{
			if (string.IsNullOrEmpty(s))
			{
				return null;
			}
			string[] array = s.Split(new char[1] { '|' });
			if (array.Length < 10)
			{
				return null;
			}
			long.TryParse(array[1], out var result);
			int.TryParse(array[4], out var result2);
			long.TryParse(array[6], out var result3);
			int.TryParse(array[9], out var result4);
			return new DuelResult
			{
				WinnerId = array[0],
				WinnerOwnerId = result,
				WinnerOwnerName = array[2],
				WinnerName = array[3],
				WinnerCaste = result2,
				LoserId = array[5],
				LoserOwnerId = result3,
				LoserOwnerName = array[7],
				LoserName = array[8],
				LoserCaste = result4
			};
		}
	}
	public static class LeaderboardStore
	{
		private static LeaderboardData _data;

		private static LeaderboardData _snapshot = new LeaderboardData();

		private static readonly Dictionary<string, float> _pairCooldown = new Dictionary<string, float>();

		private static string _loadedWorld;

		public static LeaderboardData Snapshot => _snapshot;

		public static string DataDir()
		{
			string text;
			try
			{
				text = Path.Combine(Utils.GetSaveDataPath((FileSource)1), "LostScrollsII");
			}
			catch
			{
				text = Path.Combine(Paths.ConfigPath, "LostScrollsII");
			}
			Directory.CreateDirectory(text);
			return text;
		}

		private static string Sanitize(string s)
		{
			if (string.IsNullOrEmpty(s))
			{
				return "world";
			}
			char[] invalidFileNameChars = Path.GetInvalidFileNameChars();
			foreach (char oldChar in invalidFileNameChars)
			{
				s = s.Replace(oldChar, '_');
			}
			return s;
		}

		private static string CurrentWorldName()
		{
			try
			{
				if ((Object)(object)ZNet.instance != (Object)null)
				{
					return ZNet.instance.GetWorldName();
				}
			}
			catch
			{
			}
			return "world";
		}

		public static string WorldTag()
		{
			return Sanitize(CurrentWorldName());
		}

		private static string StorePath(string world)
		{
			return Path.Combine(DataDir(), "ladder." + Sanitize(world) + ".json");
		}

		public static void LoadForCurrentWorld()
		{
			string text = (_loadedWorld = CurrentWorldName());
			string text2 = StorePath(text);
			try
			{
				if (File.Exists(text2))
				{
					_data = CompetitiveJson.ReadLeaderboard(File.ReadAllText(text2)) ?? new LeaderboardData();
					if (_data.companions == null)
					{
						_data.companions = new List<CompanionRecord>();
					}
					if (_data.parties == null)
					{
						_data.parties = new List<PartyRecord>();
					}
					Plugin.Log.LogInfo((object)$"[ladder] loaded {_data.companions.Count} duel + {_data.parties.Count} party record(s) for world '{text}'.");
				}
				else
				{
					_data = new LeaderboardData();
					Plugin.Log.LogInfo((object)("[ladder] no ladder file for world '" + text + "' — starting fresh."));
				}
			}
			catch (Exception ex)
			{
				_data = new LeaderboardData();
				Plugin.Log.LogWarning((object)("[ladder] failed to load '" + text2 + "': " + ex.Message + ". Starting fresh."));
			}
			_snapshot = _data;
		}

		public static void Save()
		{
			if (_data == null)
			{
				return;
			}
			try
			{
				File.WriteAllText(StorePath(_loadedWorld ?? CurrentWorldName()), CompetitiveJson.Write(_data, pretty: true));
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[ladder] save failed: " + ex.Message));
			}
		}

		public static string SerializeSnapshot()
		{
			return CompetitiveJson.Write(_data ?? new LeaderboardData());
		}

		public static void ApplySnapshot(string json)
		{
			try
			{
				LeaderboardData leaderboardData = CompetitiveJson.ReadLeaderboard(json) ?? new LeaderboardData();
				if (leaderboardData.companions == null)
				{
					leaderboardData.companions = new List<CompanionRecord>();
				}
				if (leaderboardData.parties == null)
				{
					leaderboardData.parties = new List<PartyRecord>();
				}
				_snapshot = leaderboardData;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[ladder] failed to apply snapshot: " + ex.Message));
			}
		}

		public static List<CompanionRecord> Ranked(int caste = -1)
		{
			return (from r in _snapshot?.companions ?? new List<CompanionRecord>()
				where r != null && (caste < 0 || r.caste == caste)
				orderby r.rating descending, r.wins descending, r.companionName ?? ""
				select r).ToList();
		}

		public static int RankOf(string companionId)
		{
			if (string.IsNullOrEmpty(companionId))
			{
				return 0;
			}
			List<CompanionRecord> list = Ranked();
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i].companionId == companionId)
				{
					return i + 1;
				}
			}
			return 0;
		}

		public static CompanionRecord Find(string companionId)
		{
			return (_snapshot?.companions ?? new List<CompanionRecord>()).FirstOrDefault((CompanionRecord r) => r != null && r.companionId == companionId);
		}

		public static PartyRecord FindParty(long ownerId)
		{
			return (_snapshot?.parties ?? new List<PartyRecord>()).FirstOrDefault((PartyRecord r) => r != null && r.ownerId == ownerId);
		}

		public static List<PartyRecord> RankedParties()
		{
			return (from r in _snapshot?.parties ?? new List<PartyRecord>()
				where r != null
				orderby r.rating descending, r.wins descending, r.ownerName ?? ""
				select r).ToList();
		}

		public static bool ApplyDuel(DuelResult r, int kFactor, float pairCooldownSeconds, out int winnerRank, out int winnerRating, out bool crossedThreshold)
		{
			winnerRank = 0;
			winnerRating = 1000;
			crossedThreshold = false;
			if (_data == null)
			{
				LoadForCurrentWorld();
			}
			if (r == null || string.IsNullOrEmpty(r.WinnerId) || string.IsNullOrEmpty(r.LoserId))
			{
				return false;
			}
			if (r.WinnerId == r.LoserId)
			{
				return false;
			}
			if (r.WinnerOwnerId == 0L || r.LoserOwnerId == 0L || r.WinnerOwnerId == r.LoserOwnerId)
			{
				return false;
			}
			CompanionRecord orCreate = GetOrCreate(r.WinnerId, r.WinnerOwnerId, r.WinnerOwnerName, r.WinnerName, r.WinnerCaste);
			CompanionRecord orCreate2 = GetOrCreate(r.LoserId, r.LoserOwnerId, r.LoserOwnerName, r.LoserName, r.LoserCaste);
			int num = RankOfLive(orCreate.companionId);
			orCreate.wins++;
			orCreate.winStreak++;
			if (orCreate.winStreak > orCreate.bestStreak)
			{
				orCreate.bestStreak = orCreate.winStreak;
			}
			orCreate2.losses++;
			orCreate2.winStreak = 0;
			orCreate2.lastMatchTicks = (orCreate.lastMatchTicks = DateTime.UtcNow.Ticks);
			string key = PairKey(r.WinnerId, r.LoserId);
			if (!_pairCooldown.TryGetValue(key, out var value) || !(Time.time - value < pairCooldownSeconds))
			{
				Rating.Apply(orCreate.rating, orCreate2.rating, kFactor, out var newWinner, out var newLoser);
				orCreate.rating = newWinner;
				orCreate2.rating = newLoser;
				_pairCooldown[key] = Time.time;
			}
			Save();
			winnerRating = orCreate.rating;
			winnerRank = RankOfLive(orCreate.companionId);
			crossedThreshold = winnerRank >= 1 && winnerRank <= 3 && (num == 0 || winnerRank < num);
			return true;
		}

		public static bool ApplyPartyDuel(PartyDuelResult r, int kFactor, out int winnerRank, out int winnerRating, out bool crossedThreshold)
		{
			winnerRank = 0;
			winnerRating = 1000;
			crossedThreshold = false;
			if (_data == null)
			{
				LoadForCurrentWorld();
			}
			if (r == null)
			{
				return false;
			}
			if (r.WinnerOwnerId == 0L || r.LoserOwnerId == 0L || r.WinnerOwnerId == r.LoserOwnerId)
			{
				return false;
			}
			PartyRecord orCreateParty = GetOrCreateParty(r.WinnerOwnerId, r.WinnerOwnerName);
			PartyRecord orCreateParty2 = GetOrCreateParty(r.LoserOwnerId, r.LoserOwnerName);
			if (!string.IsNullOrEmpty(r.WinnerPartyName))
			{
				orCreateParty.partyName = r.WinnerPartyName;
			}
			int num = RankOfLiveParty(orCreateParty.ownerId);
			orCreateParty.wins++;
			orCreateParty2.losses++;
			orCreateParty2.lastMatchTicks = (orCreateParty.lastMatchTicks = DateTime.UtcNow.Ticks);
			if (r.WinnerMembers != null && r.WinnerMembers.Count > 0)
			{
				orCreateParty.memberSnapshot = r.WinnerMembers;
				if (r.WinnerMembers.Count > orCreateParty.bestTeamSize)
				{
					orCreateParty.bestTeamSize = r.WinnerMembers.Count;
				}
			}
			if (r.LoserMembers != null && r.LoserMembers.Count > 0)
			{
				orCreateParty2.memberSnapshot = r.LoserMembers;
			}
			Rating.Apply(orCreateParty.rating, orCreateParty2.rating, kFactor, out var newWinner, out var newLoser);
			orCreateParty.rating = newWinner;
			orCreateParty2.rating = newLoser;
			Save();
			winnerRating = orCreateParty.rating;
			winnerRank = RankOfLiveParty(orCreateParty.ownerId);
			crossedThreshold = winnerRank >= 1 && winnerRank <= 3 && (num == 0 || winnerRank < num);
			return true;
		}

		public static void SetPartyName(long ownerId, string ownerName, string name)
		{
			if (ownerId != 0L)
			{
				if (_data == null)
				{
					LoadForCurrentWorld();
				}
				GetOrCreateParty(ownerId, ownerName).partyName = (name ?? string.Empty).Trim();
				Save();
			}
		}

		public static int SeasonReset()
		{
			if (_data == null)
			{
				LoadForCurrentWorld();
			}
			int count = _data.companions.Count;
			try
			{
				File.WriteAllText(StorePath(_loadedWorld ?? CurrentWorldName()).Replace(".json", $".season{_data.seasonId}.json"), CompetitiveJson.Write(_data, pretty: true));
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[ladder] season archive failed: " + ex.Message));
			}
			int num = _data.seasonId + 1;
			_data = new LeaderboardData
			{
				seasonId = num
			};
			_snapshot = _data;
			_pairCooldown.Clear();
			Save();
			Plugin.Log.LogInfo((object)$"[ladder] season reset: archived {count} record(s), now season {num}.");
			return count;
		}

		private static CompanionRecord GetOrCreate(string id, long ownerId, string ownerName, string name, int caste)
		{
			CompanionRecord companionRecord = _data.companions.FirstOrDefault((CompanionRecord c) => c != null && c.companionId == id);
			if (companionRecord == null)
			{
				companionRecord = new CompanionRecord
				{
					companionId = id,
					rating = 1000,
					seasonId = _data.seasonId
				};
				_data.companions.Add(companionRecord);
			}
			companionRecord.ownerId = ownerId;
			if (!string.IsNullOrEmpty(ownerName))
			{
				companionRecord.ownerName = ownerName;
			}
			if (!string.IsNullOrEmpty(name))
			{
				companionRecord.companionName = name;
			}
			companionRecord.caste = caste;
			return companionRecord;
		}

		private static int RankOfLive(string companionId)
		{
			List<CompanionRecord> list = (from r in _data?.companions ?? new List<CompanionRecord>()
				where r != null
				orderby r.rating descending, r.wins descending
				select r).ToList();
			for (int num = 0; num < list.Count; num++)
			{
				if (list[num].companionId == companionId)
				{
					return num + 1;
				}
			}
			return 0;
		}

		private static PartyRecord GetOrCreateParty(long ownerId, string ownerName)
		{
			PartyRecord partyRecord = _data.parties.FirstOrDefault((PartyRecord p) => p != null && p.ownerId == ownerId);
			if (partyRecord == null)
			{
				partyRecord = new PartyRecord
				{
					ownerId = ownerId,
					rating = 1000,
					seasonId = _data.seasonId
				};
				_data.parties.Add(partyRecord);
			}
			if (!string.IsNullOrEmpty(ownerName))
			{
				partyRecord.ownerName = ownerName;
			}
			return partyRecord;
		}

		private static int RankOfLiveParty(long ownerId)
		{
			List<PartyRecord> list = (from r in _data?.parties ?? new List<PartyRecord>()
				where r != null
				orderby r.rating descending, r.wins descending
				select r).ToList();
			for (int num = 0; num < list.Count; num++)
			{
				if (list[num].ownerId == ownerId)
				{
					return num + 1;
				}
			}
			return 0;
		}

		private static string PairKey(string a, string b)
		{
			if (string.CompareOrdinal(a, b) > 0)
			{
				return b + "|" + a;
			}
			return a + "|" + b;
		}
	}
	public static class LeaderboardSync
	{
		[HarmonyPatch(typeof(ZNet), "Awake")]
		private static class ZNetAwakePatch
		{
			private static void Postfix(ZNet __instance)
			{
				EnsureRegistered();
				if (__instance.IsServer())
				{
					LeaderboardStore.LoadForCurrentWorld();
					TournamentService.LoadForCurrentWorld();
					DuelInviteService.LoadForCurrentWorld();
					TournamentService.SerializerSelfTest();
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "OnDestroy")]
		private static class ZNetOnDestroyPatch
		{
			private static void Postfix()
			{
				_bound = false;
			}
		}

		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		private static class PeerInfoPatch
		{
			private static void Postfix(ZNet __instance, ZRpc rpc)
			{
				if (__instance.IsServer())
				{
					ZNetPeer peer = __instance.GetPeer(rpc);
					if (peer != null)
					{
						EnsureRegistered();
						SendTableToPeer(peer.m_uid);
						SendTournamentToPeer(peer.m_uid);
						SendInvitesToPeer(peer.m_uid);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Player), "OnSpawned")]
		private static class PlayerSpawnedPatch
		{
			private static void Postfix(Player __instance)
			{
				if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
				{
					RequestTable();
					RequestTournament();
					RequestInvites();
					RequestAdminStatus();
				}
			}
		}

		private const string RpcReportDuel = "LSII_ReportDuel";

		private const string RpcLadderPush = "LSII_LadderPush";

		private const string RpcLadderRequest = "LSII_LadderReq";

		private const string RpcRankEvent = "LSII_RankEvent";

		private const string RpcReportParty = "LSII_ReportParty";

		private const string RpcPartyRankEvent = "LSII_PartyRankEvt";

		private const string RpcTourJoinAck = "LSII_TourJoinAck";

		private const string RpcTourPush = "LSII_TourPush";

		private const string RpcTourRequest = "LSII_TourReq";

		private const string RpcTourMatch = "LSII_TourMatch";

		private const string RpcTourWon = "LSII_TourWon";

		private const string RpcAdminCmd = "LSII_AdminCmd";

		private const string RpcAdminAck = "LSII_AdminAck";

		private const string RpcSetPartyName = "LSII_SetPartyName";

		private const string RpcTourJoinEsc = "LSII_TourJoinEsc";

		private const string RpcTourWithdraw = "LSII_TourWithdraw";

		private const string RpcTourReturn = "LSII_TourReturn";

		private const string RpcTourSummon = "LSII_TourSummon";

		private const string RpcTourReseal = "LSII_TourReseal";

		private const string RpcAdminChk = "LSII_AdminChk";

		private const string RpcAdminChkResp = "LSII_AdminChkR";

		private const string RpcWagerStart = "LSII_WagerStart";

		private const string RpcTourReady = "LSII_TourReady";

		private const string RpcWagerPay = "LSII_WagerPay";

		private const string RpcWagerPrize = "LSII_WagerPrize";

		private const string RpcInvite = "LSII_Invite";

		private const string RpcInvitePush = "LSII_InvitePush";

		private const string RpcInviteReq = "LSII_InviteReq";

		private static bool _bound;

		public const string ContextTournament = "tourney";

		public const string ContextInvite = "invite";

		public static bool LocalIsAdmin { get; private set; }

		private static void EnsureRegistered()
		{
			if (!_bound && ZRoutedRpc.instance != null)
			{
				ZRoutedRpc.instance.Register<string>("LSII_ReportDuel", (Action<long, string>)OnReportDuel);
				ZRoutedRpc.instance.Register<ZPackage>("LSII_LadderPush", (Action<long, ZPackage>)OnLadderPush);
				ZRoutedRpc.instance.Register<string>("LSII_LadderReq", (Action<long, string>)OnLadderRequest);
				ZRoutedRpc.instance.Register<string>("LSII_RankEvent", (Action<long, string>)OnRankEvent);
				ZRoutedRpc.instance.Register<string>("LSII_ReportParty", (Action<long, string>)OnReportParty);
				ZRoutedRpc.instance.Register<string>("LSII_PartyRankEvt", (Action<long, string>)OnPartyRankEvent);
				ZRoutedRpc.instance.Register<string>("LSII_TourJoinAck", (Action<long, string>)OnTourJoinAck);
				ZRoutedRpc.instance.Register<ZPackage>("LSII_TourPush", (Action<long, ZPackage>)OnTourPush);
				ZRoutedRpc.instance.Register<string>("LSII_TourReq", (Action<long, string>)OnTourRequest);
				ZRoutedRpc.instance.Register<string>("LSII_TourMatch", (Action<long, string>)OnTourMatch);
				ZRoutedRpc.instance.Register<string>("LSII_TourWon", (Action<long, string>)OnTourWon);
				ZRoutedRpc.instance.Register<string>("LSII_AdminCmd", (Action<long, string>)OnAdminCmd);
				ZRoutedRpc.instance.Register<string>("LSII_AdminAck", (Action<long, string>)OnAdminAck);
				ZRoutedRpc.instance.Register<string>("LSII_SetPartyName", (Action<long, string>)OnSetPartyName);
				ZRoutedRpc.instance.Register<ZPackage>("LSII_TourJoinEsc", (Action<long, ZPackage>)OnTourJoinEsc);
				ZRoutedRpc.instance.Register<string>("LSII_TourWithdraw", (Action<long, string>)OnTourWithdraw);
				ZRoutedRpc.instance.Register<ZPackage>("LSII_TourReturn", (Action<long, ZPackage>)OnTourReturn);
				ZRoutedRpc.instance.Register<ZPackage>("LSII_TourSummon", (Action<long, ZPackage>)OnTourSummon);
				ZRoutedRpc.instance.Register<ZPackage>("LSII_TourReseal", (Action<long, ZPackage>)OnTourReseal);
				ZRoutedRpc.instance.Register<string>("LSII_AdminChk", (Action<long, string>)OnAdminChk);
				ZRoutedRpc.instance.Register<string>("LSII_AdminChkR", (Action<long, string>)OnAdminChkResp);
				ZRoutedRpc.instance.Register<string>("LSII_WagerStart", (Action<long, string>)OnWagerStart);
				ZRoutedRpc.instance.Register<string>("LSII_TourReady", (Action<long, string>)OnTourReady);
				ZRoutedRpc.instance.Register<string>("LSII_WagerPay", (Action<long, string>)OnWagerPay);
				ZRoutedRpc.instance.Register<string>("LSII_WagerPrize", (Action<long, string>)OnWagerPrize);
				ZRoutedRpc.instance.Register<ZPackage>("LSII_Invite", (Action<long, ZPackage>)OnInvite);
				ZRoutedRpc.instance.Register<ZPackage>("LSII_InvitePush", (Action<long, ZPackage>)OnInvitePush);
				ZRoutedRpc.instance.Register<string>("LSII_InviteReq", (Action<long, string>)OnInviteRequest);
				_bound = true;
				Plugin.Log.LogInfo((object)"[ladder] RPCs registered.");
			}
		}

		public static void ReportDuel(DuelResult result)
		{
			if (result != null && ZRoutedRpc.instance != null)
			{
				long serverPeerID = ZRoutedRpc.instance.GetServerPeerID();
				ZRoutedRpc.instance.InvokeRoutedRPC(serverPeerID, "LSII_ReportDuel", new object[1] { result.Encode() });
			}
		}

		private static void OnReportDuel(long sender, string encoded)
		{
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			DuelResult duelResult = DuelResult.Decode(encoded);
			if (duelResult == null)
			{
				return;
			}
			TournamentService.NotifyDuelResult(duelResult.WinnerId, duelResult.LoserId);
			DuelInviteService.NotifyDuelResult(duelResult.WinnerId, duelResult.LoserId);
			if (LeaderboardStore.ApplyDuel(duelResult, Plugin.RankingKFactor.Value, Plugin.RankingPairCooldown.Value, out var winnerRank, out var winnerRating, out var crossedThreshold))
			{
				Plugin.Log.LogInfo((object)("[ladder] duel recorded: '" + duelResult.WinnerName + "' beat '" + duelResult.LoserName + "' " + $"(rank #{winnerRank}, {winnerRating})."));
				BroadcastTable();
				if (crossedThreshold)
				{
					string text = string.Join("|", duelResult.WinnerCaste.ToString(), winnerRank.ToString(), winnerRating.ToString(), (duelResult.WinnerName ?? string.Empty).Replace('|', '/'), (duelResult.WinnerOwnerName ?? string.Empty).Replace('|', '/'));
					ZRoutedRpc.instance.InvokeRoutedRPC(sender, "LSII_RankEvent", new object[1] { text });
				}
			}
		}

		public static void ReportPartyDuel(PartyDuelResult result)
		{
			if (result != null && ZRoutedRpc.instance != null)
			{
				long serverPeerID = ZRoutedRpc.instance.GetServerPeerID();
				ZRoutedRpc.instance.InvokeRoutedRPC(serverPeerID, "LSII_ReportParty", new object[1] { result.Encode() });
			}
		}

		private static void OnReportParty(long sender, string encoded)
		{
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			PartyDuelResult partyDuelResult = PartyDuelResult.Decode(encoded);
			if (partyDuelResult == null)
			{
				return;
			}
			TournamentService.NotifyPartyResult(partyDuelResult.WinnerOwnerId, partyDuelResult.LoserOwnerId);
			if (LeaderboardStore.ApplyPartyDuel(partyDuelResult, Plugin.RankingKFactor.Value, out var winnerRank, out var winnerRating, out var crossedThreshold))
			{
				Plugin.Log.LogInfo((object)("[ladder] party duel recorded: '" + partyDuelResult.WinnerOwnerName + "' beat " + $"'{partyDuelResult.LoserOwnerName}' (party rank #{winnerRank}, {winnerRating})."));
				BroadcastTable();
				if (crossedThreshold)
				{
					string text = LeaderboardStore.FindParty(partyDuelResult.WinnerOwnerId)?.partyName;
					string text2 = string.Join("|", (partyDuelResult.WinnerOwnerName ?? string.Empty).Replace('|', '/'), winnerRank.ToString(), winnerRating.ToString(), (text ?? string.Empty).Replace('|', '/'));
					ZRoutedRpc.instance.InvokeRoutedRPC(sender, "LSII_PartyRankEvt", new object[1] { text2 });
				}
			}
		}

		private static void OnPartyRankEvent(long sender, string payload)
		{
			if ((Object)(object)Player.m_localPlayer == (Object)null || string.IsNullOrEmpty(payload))
			{
				return;
			}
			string[] array = payload.Split(new char[1] { '|' });
			if (array.Length >= 3)
			{
				int.TryParse(array[1], out var result);
				int.TryParse(array[2], out var result2);
				string partyName = ((array.Length > 3) ? array[3] : null);
				ServerGuideBridge.RaisePartyRankChanged(array[0], result, result2, partyName);
				if (result == 1)
				{
					ServerGuideBridge.RaisePartyRankFirst(array[0], result2, partyName);
				}
			}
		}

		private static string TourSubject(int caste)
		{
			if (caste >= 0)
			{
				DvergrCaste dvergrCaste = (DvergrCaste)caste;
				return dvergrCaste.ToString();
			}
			return "party";
		}

		private static void OnTourJoinAck(long sender, string payload)
		{
			if ((Object)(object)Player.m_localPlayer == (Object)null)
			{
				return;
			}
			string[] array = payload.Split(new char[1] { '|' });
			if (array.Length >= 3)
			{
				if ((Object)(object)MessageHud.instance != (Object)null)
				{
					MessageHud.instance.ShowMessage((MessageType)1, array[2], 0, (Sprite)null, false);
				}
				if (array[0] == "1")
				{
					ServerGuideBridge.RaiseTournamentJoined(array[1]);
				}
			}
		}

		public static void BroadcastTournament()
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			if (ZRoutedRpc.instance != null)
			{
				string text = TournamentService.SerializeSnapshot();
				Plugin.Log.LogInfo((object)string.Format("[tourney] broadcast: jsonLen={0}, hasEntrants={1}.", text.Length, text.Contains("entrantId")));
				ZPackage val = new ZPackage();
				val.Write(text);
				ZRoutedRpc.instance.InvokeRoutedRPC(0L, "LSII_TourPush", new object[1] { val });
			}
		}

		private static void SendTournamentToPeer(long peer)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			if (ZRoutedRpc.instance != null)
			{
				ZPackage val = new ZPackage();
				val.Write(TournamentService.SerializeSnapshot());
				ZRoutedRpc.instance.InvokeRoutedRPC(peer, "LSII_TourPush", new object[1] { val });
			}
		}

		private static void OnTourPush(long sender, ZPackage pkg)
		{
			if (!((Object)(object)ZNet.instance != (Object)null) || !ZNet.instance.IsServer())
			{
				TournamentService.ApplySnapshot(pkg.ReadString());
			}
		}

		public static void RequestTournament()
		{
			if (ZRoutedRpc.instance != null && (!((Object)(object)ZNet.instance != (Object)null) || !ZNet.instance.IsServer()))
			{
				ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), "LSII_TourReq", new object[1] { string.Empty });
			}
		}

		private static void OnTourRequest(long sender, string _)
		{
			if (!((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer())
			{
				SendTournamentToPeer(sender);
			}
		}

		public static void SendTournamentMatch(string targetName, int round, string opponentLabel, int caste)
		{
			if (ZRoutedRpc.instance != null)
			{
				string text = string.Join("|", S(targetName), round.ToString(), S(opponentLabel), caste.ToString());
				ZRoutedRpc.instance.InvokeRoutedRPC(0L, "LSII_TourMatch", new object[1] { text });
			}
			static string S(string s)
			{
				return (s ?? string.Empty).Replace('|', '/');
			}
		}

		private static void OnTourMatch(long sender, string payload)
		{
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null))
			{
				string[] array = payload.Split(new char[1] { '|' });
				if (array.Length >= 4 && string.Equals(array[0], localPlayer.GetPlayerName(), StringComparison.Ordinal))
				{
					int.TryParse(array[1], out var result);
					int.TryParse(array[3], out var result2);
					ServerGuideBridge.RaiseTournamentMatch(TourSubject(result2), result, array[2]);
				}
			}
		}

		public static void SendTournamentWon(string targetName, string mode, int bracketSize, int caste)
		{
			if (ZRoutedRpc.instance != null)
			{
				string text = string.Join("|", S(targetName), S(mode), bracketSize.ToString(), caste.ToString());
				ZRoutedRpc.instance.InvokeRoutedRPC(0L, "LSII_TourWon", new object[1] { text });
			}
			static string S(string s)
			{
				return (s ?? string.Empty).Replace('|', '/');
			}
		}

		private static void OnTourWon(long sender, string payload)
		{
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null))
			{
				string[] array = payload.Split(new char[1] { '|' });
				if (array.Length >= 4 && string.Equals(array[0], localPlayer.GetPlayerName(), StringComparison.Ordinal))
				{
					int.TryParse(array[2], out var result);
					int.TryParse(array[3], out var result2);
					ServerGuideBridge.RaiseTournamentWon(TourSubject(result2), array[1], result);
				}
			}
		}

		public static void SendAdminCommand(string cmd)
		{
			if (!string.IsNullOrEmpty(cmd))
			{
				if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
				{
					ShowLocal(ExecuteAdmin(cmd));
				}
				else if (ZRoutedRpc.instance != null)
				{
					ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), "LSII_AdminCmd", new object[1] { cmd });
				}
			}
		}

		private static void OnAdminCmd(long sender, string cmd)
		{
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			ZNetPeer peer = ZNet.instance.GetPeer(sender);
			object obj;
			if (peer == null)
			{
				obj = null;
			}
			else
			{
				ISocket socket = peer.m_socket;
				obj = ((socket != null) ? socket.GetHostName() : null);
			}
			string text = (string)obj;
			if (string.IsNullOrEmpty(text) || !ZNet.instance.IsAdmin(text))
			{
				Plugin.Log.LogWarning((object)$"[tourney] non-admin sender ({sender}, host='{text}') tried admin cmd '{cmd}' — denied.");
				ZRoutedRpc.instance.InvokeRoutedRPC(sender, "LSII_AdminAck", new object[1] { "Only a server admin can do that." });
				return;
			}
			string text2 = ExecuteAdmin(cmd);
			if (!string.IsNullOrEmpty(text2))
			{
				ZRoutedRpc.instance.InvokeRoutedRPC(sender, "LSII_AdminAck", new object[1] { text2 });
			}
		}

		private static void OnAdminAck(long sender, string msg)
		{
			ShowLocal(msg);
		}

		public static void RequestAdminStatus()
		{
			if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
			{
				LocalIsAdmin = true;
			}
			else if (ZRoutedRpc.instance != null)
			{
				ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), "LSII_AdminChk", new object[1] { string.Empty });
			}
		}

		private static void OnAdminChk(long sender, string _)
		{
			if (!((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer())
			{
				ZNetPeer peer = ZNet.instance.GetPeer(sender);
				object obj;
				if (peer == null)
				{
					obj = null;
				}
				else
				{
					ISocket socket = peer.m_socket;
					obj = ((socket != null) ? socket.GetHostName() : null);
				}
				string text = (string)obj;
				bool flag = !string.IsNullOrEmpty(text) && ZNet.instance.IsAdmin(text);
				Plugin.Log.LogInfo((object)$"[tourney] admin check for sender {sender} (host='{text}') => {flag}.");
				ZRoutedRpc.instance.InvokeRoutedRPC(sender, "LSII_AdminChkR", new object[1] { flag ? "1" : "0" });
			}
		}

		private static void OnAdminChkResp(long sender, string v)
		{
			LocalIsAdmin = v == "1";
			Plugin.Log.LogInfo((object)$"[tourney] server says local player admin = {LocalIsAdmin}.");
		}

		public static void SendPartyName(string name)
		{
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null))
			{
				string text = string.Join("|", localPlayer.GetPlayerID().ToString(), S(localPlayer.GetPlayerName()), S(name));
				if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
				{
					ApplyPartyName(text);
				}
				else if (ZRoutedRpc.instance != null)
				{
					ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), "LSII_SetPartyName", new object[1] { text });
				}
			}
			static string S(string s)
			{
				return (s ?? string.Empty).Replace('|', '/');
			}
		}

		private static void OnSetPartyName(long sender, string payload)
		{
			if (!((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer())
			{
				ApplyPartyName(payload);
			}
		}

		private static void ApplyPartyName(string payload)
		{
			string[] array = (payload ?? string.Empty).Split(new char[1] { '|' });
			if (array.Length >= 3)
			{
				long.TryParse(array[0], out var result);
				LeaderboardStore.SetPartyName(result, array[1], array[2]);
				BroadcastTable();
			}
		}

		public static void SendTournamentJoinEscrow(string key, string entrantId, long ownerId, string ownerName, string label, int caste, int seedRating, List<string> payloads, int level = 0, int clientPaidCoins = 0)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			if (ZRoutedRpc.instance == null)
			{
				return;
			}
			ZPackage val = new ZPackage();
			val.Write(entrantId ?? string.Empty);
			val.Write(ownerId);
			val.Write(ownerName ?? string.Empty);
			val.Write(label ?? string.Empty);
			val.Write(caste);
			val.Write(seedRating);
			val.Write(payloads?.Count ?? 0);
			if (payloads != null)
			{
				foreach (string payload in payloads)
				{
					val.Write(payload ?? string.Empty);
				}
			}
			val.Write(level);
			val.Write(key ?? string.Empty);
			val.Write(clientPaidCoins);
			if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
			{
				HandleJoinEscrow(0L, val);
				return;
			}
			ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), "LSII_TourJoinEsc", new object[1] { val });
		}

		private static void OnTourJoinEsc(long sender, ZPackage pkg)
		{
			HandleJoinEscrow(sender, pkg);
		}

		private static void HandleJoinEscrow(long sender, ZPackage pkg)
		{
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			pkg.SetPos(0);
			string entrantId = pkg.ReadString();
			long ownerId = pkg.ReadLong();
			string ownerName = pkg.ReadString();
			string label = pkg.ReadString();
			int caste = pkg.ReadInt();
			int seedRating = pkg.ReadInt();
			int num = pkg.ReadInt();
			List<string> payloads = new List<string>(num);
			for (int i = 0; i < num; i++)
			{
				payloads.Add(pkg.ReadString());
			}
			int level = 0;
			string key = string.Empty;
			int clientPaidCoins = 0;
			try
			{
				level = pkg.ReadInt();
				key = pkg.ReadString();
				clientPaidCoins = pkg.ReadInt();
			}
			catch
			{
			}
			string totemPayload = ((caste >= 0 && payloads.Count > 0) ? payloads[0] : null);
			List<string> teamPayloads = ((caste < 0) ? payloads : null);
			TournamentService.Join(key, entrantId, ownerId, ownerName, label, caste, seedRating, totemPayload, teamPayloads, level, clientPaidCoins, delegate(bool ok, string status)
			{
				Plugin.Log.LogInfo((object)($"[tourney] join from sender={sender} into slot '{key}': owner={ownerId}/'{ownerName}', " + $"label='{label}', level={level}, paidCoins={clientPaidCoins}, payloadLen={totemPayload?.Length ?? 0} => \"{status}\" " + $"(entrants now {TournamentService.Get(key)?.entrants?.Count ?? (-1)})."));
				string text = string.Join("|", ok ? "1" : "0", TourSubject(caste), status ?? string.Empty);
				if (sender == 0L)
				{
					ShowLocal(status);
				}
				else
				{
					ZRoutedRpc.instance.InvokeRoutedRPC(sender, "LSII_TourJoinAck", new object[1] { text });
				}
				if (ok && sender == 0L)
				{
					ServerGuideBridge.RaiseTournamentJoined(TourSubject(caste));
				}
				if (!ok)
				{
					if (payloads.Count > 0)
					{
						ReturnEscrowToOwners(new Dictionary<long, List<string>> { { ownerId, payloads } });
					}
					if (clientPaidCoins > 0)
					{
						SendWagerPayout(ownerId, clientPaidCoins, "entry refunded");
					}
				}
			});
		}

		public static void SendTournamentWithdraw(string key)
		{
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null) && ZRoutedRpc.instance != null)
			{
				string text = localPlayer.GetPlayerID() + "|" + (key ?? string.Empty);
				if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
				{
					HandleWithdraw(0L, text);
					return;
				}
				ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), "LSII_TourWithdraw", new object[1] { text });
			}
		}

		private static void OnTourWithdraw(long sender, string payload)
		{
			HandleWithdraw(sender, payload);
		}

		private static void HandleWithdraw(long sender, string payload)
		{
			if (!((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer())
			{
				string[] array = (payload ?? string.Empty).Split(new char[1] { '|' });
				long.TryParse(array[0], out var result);
				string status;
				List<string> list = TournamentService.Withdraw((array.Length > 1) ? array[1] : string.Empty, result, out status);
				if (sender == 0L)
				{
					ShowLocal(status);
				}
				else
				{
					ZRoutedRpc.instance.InvokeRoutedRPC(sender, "LSII_AdminAck", new object[1] { status });
				}
				if (list.Count > 0)
				{
					ReturnEscrowToOwners(new Dictionary<long, List<string>> { { result, list } });
				}
			}
		}

		public static void SendStartWagered(string currency, int clientPaidCoins)
		{
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null) && ZRoutedRpc.instance != null)
			{
				string text = string.Join("|", currency ?? string.Empty, localPlayer.GetPlayerID().ToString(), (localPlayer.GetPlayerName() ?? string.Empty).Replace('|', '/'), clientPaidCoins.ToString());
				if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
				{
					HandleStartWagered(0L, text);
					return;
				}
				ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), "LSII_WagerStart", new object[1] { text });
			}
		}

		private static void OnWagerStart(long sender, string payload)
		{
			HandleStartWagered(sender, payload);
		}

		private static void HandleStartWagered(long sender, string payload)
		{
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			string[] array = (payload ?? string.Empty).Split(new char[1] { '|' });
			if (array.Length < 4)
			{
				return;
			}
			WagerCurrency wagerCurrency = Wager.Parse(array[0]);
			long.TryParse(array[1], out var hostId);
			string hostName = array[2];
			int.TryParse(array[3], out var paidCoins);
			if (wagerCurrency == WagerCurrency.Coins && paidCoins < Wager.TournamentFee(wagerCurrency))
			{
				Reply(sender, "You do not have the Coins to open a tournament.");
				if (paidCoins > 0)
				{
					SendWagerPayout(hostId, paidCoins, "tournament not opened");
				}
				return;
			}
			TournamentService.StartWagered(wagerCurrency, hostId, hostName, delegate(bool ok, string msg)
			{
				Reply(sender, msg);
				if (!ok && paidCoins > 0)
				{
					SendWagerPayout(hostId, paidCoins, "tournament not opened");
				}
			});
		}

		public static void SendTournamentReady(string key)
		{
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null) && ZRoutedRpc.instance != null)
			{
				string text = localPlayer.GetPlayerID() + "|" + (key ?? string.Empty);
				if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
				{
					HandleReady(0L, text);
					return;
				}
				ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), "LSII_TourReady", new object[1] { text });
			}
		}

		private static void OnTourReady(long sender, string payload)
		{
			HandleReady(sender, payload);
		}

		private static void HandleReady(long sender, string payload)
		{
			if (!((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer())
			{
				string[] array = (payload ?? string.Empty).Split(new char[1] { '|' });
				long.TryParse(array[0], out var result);
				string key = ((array.Length > 1) ? array[1] : string.Empty);
				Reply(sender, TournamentService.SetReady(key, result));
			}
		}

		public static void SendWagerPayout(long ownerId, int amount, string reason)
		{
			if (ZRoutedRpc.instance != null && amount > 0)
			{
				string text = string.Join("|", ownerId.ToString(), amount.ToString(), (reason ?? string.Empty).Replace('|', '/'));
				ZRoutedRpc.instance.InvokeRoutedRPC(0L, "LSII_WagerPay", new object[1] { text });
			}
		}

		private static void OnWagerPay(long sender, string payload)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			string[] array = (payload ?? string.Empty).Split(new char[1] { '|' });
			if (array.Length < 2)
			{
				return;
			}
			long.TryParse(array[0], out var result);
			if (result == localPlayer.GetPlayerID())
			{
				int.TryParse(array[1], out var result2);
				if (result2 > 0)
				{
					Wager.GiveCoins(localPlayer, result2);
					string text = ((array.Length > 2) ? array[2] : string.Empty);
					ShowLocal(string.IsNullOrEmpty(text) ? $"+{result2} Coins" : $"+{result2} Coins — {text}");
				}
			}
		}

		public static void SendTournamentPrize(string targetName, string currency, int amount)
		{
			if (ZRoutedRpc.instance != null)
			{
				string text = string.Join("|", (targetName ?? string.Empty).Replace('|', '/'), currency ?? string.Empty, amount.ToString(), "tournament");
				ZRoutedRpc.instance.InvokeRoutedRPC(0L, "LSII_WagerPrize", new object[1] { text });
			}
		}

		private static void OnWagerPrize(long sender, string payload)
		{
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null))
			{
				string[] array = (payload ?? string.Empty).Split(new char[1] { '|' });
				if (array.Length >= 4 && string.Equals(array[0], localPlayer.GetPlayerName(), StringComparison.Ordinal))
				{
					int.TryParse(array[2], out var result);
					ServerGuideBridge.RaiseTournamentPrize(array[1], result);
				}
			}
		}

		private static void Reply(long sender, string message)
		{
			if (!string.IsNullOrEmpty(message))
			{
				if (sender == 0L)
				{
					ShowLocal(message);
				}
				else if (ZRoutedRpc.instance != null)
				{
					ZRoutedRpc.instance.InvokeRoutedRPC(sender, "LSII_AdminAck", new object[1] { message });
				}
			}
		}

		public static void ReturnEscrowToOwners(Dictionary<long, List<string>> byOwner)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			if (ZRoutedRpc.instance == null || byOwner == null)
			{
				return;
			}
			foreach (KeyValuePair<long, List<string>> item in byOwner)
			{
				if (item.Value == null || item.Value.Count == 0)
				{
					continue;
				}
				ZPackage val = new ZPackage();
				val.Write(item.Key);
				val.Write(item.Value.Count);
				foreach (string item2 in item.Value)
				{
					val.Write(item2 ?? string.Empty);
				}
				ZRoutedRpc.instance.InvokeRoutedRPC(0L, "LSII_TourReturn", new object[1] { val });
			}
		}

		private static void OnTourReturn(long sender, ZPackage pkg)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			pkg.SetPos(0);
			if (pkg.ReadLong() != localPlayer.GetPlayerID())
			{
				return;
			}
			int num = pkg.ReadInt();
			int num2 = 0;
			for (int i = 0; i < num; i++)
			{
				ItemData val = TotemConversionService.BuildTotemFromPayload(pkg.ReadString());
				if (val != null && (((Humanoid)localPlayer).GetInventory().AddItem(val) || !((Object)(object)ItemDrop.DropItem(val, 1, ((Component)localPlayer).transform.position + Vector3.up, ((Component)localPlayer).transform.rotation) == (Object)null)))
				{
					num2++;
				}
			}
			if (num2 > 0 && (Object)(object)MessageHud.instance != (Object)null)
			{
				MessageHud.instance.ShowMessage((MessageType)1, (num2 == 1) ? "Your companion totem is returned." : $"{num2} companion totems returned.", 0, (Sprite)null, false);
			}
		}

		public static void SummonForMatch(long ownerId, string entrantId, string mode, string opponentEntrantId, string opponentLabel, int round, List<string> payloads, string context = "tourney")
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			if (ZRoutedRpc.instance == null)
			{
				return;
			}
			ZPackage val = new ZPackage();
			val.Write(ownerId);
			val.Write(entrantId ?? string.Empty);
			val.Write(mode ?? "1v1");
			val.Write(opponentEntrantId ?? string.Empty);
			val.Write(opponentLabel ?? string.Empty);
			val.Write(round);
			val.Write(payloads?.Count ?? 0);
			if (payloads != null)
			{
				foreach (string payload in payloads)
				{
					val.Write(payload ?? string.Empty);
				}
			}
			val.Write(context ?? "tourney");
			ZRoutedRpc.instance.InvokeRoutedRPC(0L, "LSII_TourSummon", new object[1] { val });
		}

		private static void OnTourSummon(long sender, ZPackage pkg)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			pkg.SetPos(0);
			if (pkg.ReadLong() == localPlayer.GetPlayerID())
			{
				string entrantId = pkg.ReadString();
				string mode = pkg.ReadString();
				string opponentEntrantId = pkg.ReadString();
				string opponentLabel = pkg.ReadString();
				int round = pkg.ReadInt();
				int num = pkg.ReadInt();
				List<string> list = new List<string>(num);
				for (int i = 0; i < num; i++)
				{
					list.Add(pkg.ReadString());
				}
				string context = "tourney";
				try
				{
					context = pkg.ReadString();
				}
				catch
				{
				}
				TournamentClient.SummonForMatch(localPlayer, entrantId, mode, opponentEntrantId, opponentLabel, round, list, context);
			}
		}

		public static void SendReseal(string entrantId, List<string> payloads)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			if (ZRoutedRpc.instance == null)
			{
				return;
			}
			ZPackage val = new ZPackage();
			val.Write(entrantId ?? string.Empty);
			val.Write(payloads?.Count ?? 0);
			if (payloads != null)
			{
				foreach (string payload in payloads)
				{
					val.Write(payload ?? string.Empty);
				}
			}
			if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
			{
				HandleReseal(val);
				return;
			}
			ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), "LSII_TourReseal", new object[1] { val });
		}

		private static void OnTourReseal(long sender, ZPackage pkg)
		{
			HandleReseal(pkg);
		}

		private static void HandleReseal(ZPackage pkg)
		{
			if (!((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer())
			{
				pkg.SetPos(0);
				string entrantId = pkg.ReadString();
				int num = pkg.ReadInt();
				List<string> list = new List<string>(num);
				for (int i = 0; i < num; i++)
				{
					list.Add(pkg.ReadString());
				}
				if (TournamentService.FindEntrant(entrantId) != null)
				{
					TournamentService.UpdateEscrow(entrantId, list);
				}
				else
				{
					DuelInviteService.UpdateEscrow(entrantId, list);
				}
			}
		}

		public static void SendInviteAction(string action, string inviteId, string currency, string entrantId, string label, int level, int caste, string payload, int clientPaidCoins)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null) && ZRoutedRpc.instance != null)
			{
				ZPackage val = new ZPackage();
				val.Write(action ?? string.Empty);
				val.Write(inviteId ?? string.Empty);
				val.Write(currency ?? string.Empty);
				val.Write(localPlayer.GetPlayerID());
				val.Write(localPlayer.GetPlayerName() ?? string.Empty);
				val.Write(entrantId ?? string.Empty);
				val.Write(label ?? string.Empty);
				val.Write(level);
				val.Write(caste);
				val.Write(payload ?? string.Empty);
				val.Write(clientPaidCoins);
				if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
				{
					HandleInvite(0L, val);
					return;
				}
				ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), "LSII_Invite", new object[1] { val });
			}
		}

		private static void OnInvite(long sender, ZPackage pkg)
		{
			HandleInvite(sender, pkg);
		}

		private static void HandleInvite(long sender, ZPackage pkg)
		{
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			pkg.SetPos(0);
			string text = pkg.ReadString();
			string inviteId = pkg.ReadString();
			string s = pkg.ReadString();
			long ownerId = pkg.ReadLong();
			string text2 = pkg.ReadString();
			string entrantId = pkg.ReadString();
			string label = pkg.ReadString();
			int level = pkg.ReadInt();
			int caste = pkg.ReadInt();
			string payload = pkg.ReadString();
			int paidCoins = pkg.ReadInt();
			switch (text)
			{
			case "post":
				DuelInviteService.Post(Wager.Parse(s), ownerId, text2, entrantId, label, level, caste, payload, paidCoins, delegate(bool ok, string msg)
				{
					if (ok)
					{
						Reply(sender, msg);
					}
					else
					{
						Reject(msg);
					}
				});
				break;
			case "accept":
				DuelInviteService.Accept(inviteId, ownerId, text2, entrantId, label, level, caste, payload, paidCoins, delegate(bool ok, string msg)
				{
					if (ok)
					{
						Reply(sender, msg);
					}
					else
					{
						Reject(msg);
					}
				});
				break;
			case "ready":
				Reply(sender, DuelInviteService.SetReady(inviteId, ownerId));
				break;
			case "withdraw":
			{
				string status;
				List<KeyValuePair<long, string>> list = DuelInviteService.Withdraw(inviteId, ownerId, out status);
				Reply(sender, status);
				Dictionary<long, List<string>> dictionary = new Dictionary<long, List<string>>();
				foreach (KeyValuePair<long, string> item in list)
				{
					if (!dictionary.TryGetValue(item.Key, out var value))
					{
						value = new List<string>();
						dictionary[item.Key] = value;
					}
					value.Add(item.Value);
				}
				if (dictionary.Count > 0)
				{
					ReturnEscrowToOwners(dictionary);
				}
				break;
			}
			default:
				Reply(sender, "Unknown invite action '" + text + "'.");
				break;
			}
			void Reject(string message)
			{
				Reply(sender, message);
				if (!string.IsNullOrEmpty(payload))
				{
					ReturnEscrowToOwners(new Dictionary<long, List<string>> { 
					{
						ownerId,
						new List<string> { payload }
					} });
				}
				if (paidCoins > 0)
				{
					SendWagerPayout(ownerId, paidCoins, "stake refunded");
				}
			}
		}

		public static void BroadcastInvites()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			if (ZRoutedRpc.instance != null)
			{
				ZPackage val = new ZPackage();
				val.Write(DuelInviteService.SerializeSnapshot());
				ZRoutedRpc.instance.InvokeRoutedRPC(0L, "LSII_InvitePush", new object[1] { val });
			}
		}

		private static void SendInvitesToPeer(long peer)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			if (ZRoutedRpc.instance != null)
			{
				ZPackage val = new ZPackage();
				val.Write(DuelInviteService.SerializeSnapshot());
				ZRoutedRpc.instance.InvokeRoutedRPC(peer, "LSII_InvitePush", new object[1] { val });
			}
		}

		private static void OnInvitePush(long sender, ZPackage pkg)
		{
			if (!((Object)(object)ZNet.instance != (Object)null) || !ZNet.instance.IsServer())
			{
				DuelInviteService.ApplySnapshot(pkg.ReadString());
			}
		}

		public static void RequestInvites()
		{
			if (ZRoutedRpc.instance != null && (!((Object)(object)ZNet.instance != (Object)null) || !ZNet.instance.IsServer()))
			{
				ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), "LSII_InviteReq", new object[1] { string.Empty });
			}
		}

		private static void OnInviteRequest(long sender, string _)
		{
			if (!((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer())
			{
				SendInvitesToPeer(sender);
			}
		}

		private static void ShowLocal(string msg)
		{
			if (!string.IsNullOrEmpty(msg) && (Object)(object)MessageHud.instance != (Object)null)
			{
				MessageHud.instance.ShowMessage((MessageType)1, msg, 0, (Sprite)null, false);
			}
		}

		private static string ExecuteAdmin(string cmd)
		{
			string[] array = (cmd ?? string.Empty).Split(new char[1] { '|' });
			switch ((array.Length != 0) ? array[0] : string.Empty)
			{
			case "start":
			{
				string mode = ((array.Length > 1) ? array[1] : "1v1");
				int result = 0;
				if (array.Length > 2)
				{
					int.TryParse(array[2], out result);
				}
				return TournamentService.Start(eliminationType: (array.Length > 3) ? array[3] : "single", mode: mode, size: result);
			}
			case "begin":
				return TournamentService.Begin(Slot(array, 1));
			case "cancel":
				return TournamentService.Cancel(Slot(array, 1));
			case "forfeit":
				if (array.Length <= 1)
				{
					return "Usage: forfeit <name>.";
				}
				return TournamentService.Forfeit(Slot(array, 2), array[1]);
			case "release":
			{
				if (array.Length < 2)
				{
					return "Usage: release <entrant name>.";
				}
				long ownerId;
				string status;
				List<string> list = TournamentService.ReleaseEntrant(Slot(array, 2), array[1], out ownerId, out status);
				if (list.Count > 0)
				{
					ReturnEscrowToOwners(new Dictionary<long, List<string>> { { ownerId, list } });
				}
				return status;
			}
			case "activate":
				return TournamentService.ActivateCurrentRound(Slot(array, 1));
			case "season":
			{
				int num2 = LeaderboardStore.SeasonReset();
				BroadcastTable();
				return $"Duel season reset — archived {num2} record(s).";
			}
			case "bountyseason":
			{
				int num = BountyLeaderboardStore.SeasonReset();
				BountySync.BroadcastLadder();
				return $"Bounty season reset — archived {num} hunter record(s).";
			}
			default:
				return "Unknown admin action '" + ((array.Length != 0) ? array[0] : "") + "'.";
			}
		}

		private static string Slot(string[] parts, int index)
		{
			if (parts == null || parts.Length <= index)
			{
				return string.Empty;
			}
			return parts[index];
		}

		public static void BroadcastTable()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			if (ZRoutedRpc.instance != null)
			{
				ZPackage val = new ZPackage();
				val.Write(LeaderboardStore.SerializeSnapshot());
				ZRoutedRpc.instance.InvokeRoutedRPC(0L, "LSII_LadderPush", new object[1] { val });
			}
		}

		public static void SendTableToPeer(long peer)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			if (ZRoutedRpc.instance != null)
			{
				ZPackage val = new ZPackage();
				val.Write(LeaderboardStore.SerializeSnapshot());
				ZRoutedRpc.instance.InvokeRoutedRPC(peer, "LSII_LadderPush", new object[1] { val });
			}
		}

		private static void OnLadderPush(long sender, ZPackage pkg)
		{
			if (!((Object)(object)ZNet.instance != (Object)null) || !ZNet.instance.IsServer())
			{
				LeaderboardStore.ApplySnapshot(pkg.ReadString());
			}
		}

		public static void RequestTable()
		{
			if (ZRoutedRpc.instance != null && (!((Object)(object)ZNet.instance != (Object)null) || !ZNet.instance.IsServer()))
			{
				long serverPeerID = ZRoutedRpc.instance.GetServerPeerID();
				ZRoutedRpc.instance.InvokeRoutedRPC(serverPeerID, "LSII_LadderReq", new object[1] { string.Empty });
			}
		}

		private static void OnLadderRequest(long sender, string _)
		{
			if (!((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer())
			{
				SendTableToPeer(sender);
			}
		}

		private static void OnRankEvent(long sender, string payload)
		{
			if ((Object)(object)Player.m_localPlayer == (Object)null || string.IsNullOrEmpty(payload))
			{
				return;
			}
			string[] array = payload.Split(new char[1] { '|' });
			if (array.Length >= 5)
			{
				int.TryParse(array[0], out var result);
				int.TryParse(array[1], out var result2);
				int.TryParse(array[2], out var result3);
				ServerGuideBridge.RaiseRankChanged(result, result2, result3, array[3], array[4]);
				if (result2 == 1)
				{
					ServerGuideBridge.RaiseRankFirst(result, result3, array[3], array[4]);
				}
			}
		}
	}
	public static class Rating
	{
		public const int StartRating = 1000;

		public const int Floor = 100;

		public static double Expected(int a, int b)
		{
			return 1.0 / (1.0 + Math.Pow(10.0, (double)(b - a) / 400.0));
		}

		public static void Apply(int winner, int loser, int kFactor, out int newWinner, out int newLoser)
		{
			double num = Expected(winner, loser);
			double num2 = 1.0 - num;
			newWinner = winner + (int)Math.Round((double)kFactor * (1.0 - num));
			newLoser = loser + (int)Math.Round((double)kFactor * (0.0 - num2));
			if (newLoser < 100)
			{
				newLoser = 100;
			}
			if (newWinner < 100)
			{
				newWinner = 100;
			}
		}
	}
	[Serializable]
	public class TournamentEntrant
	{
		public string entrantId;

		public long ownerId;

		public string ownerName;

		public string label;

		public int caste;

		public int seedRating;

		public bool eliminated;

		public int level;

		public int losses;

		public int wins;

		public string totemPayload;

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

		public int feePaid;
	}
	[Serializable]
	public class TournamentMatch
	{
		public int round;

		public string aId;

		public string bId;

		public string aLabel;

		public string bLabel;

		public int aLevel;

		public int bLevel;

		public string winnerId;

		public string bracket = "W";

		public bool aReady;

		public bool bReady;

		public bool activated;
	}
	[Serializable]
	public class TournamentState
	{
		public string key = "";

		public string currency = "";

		public int entryFee;

		public int prize;

		public long hostId;

		public string hostName = "";

		public long openedTicks;

		public int hostCredit;

		public long completedTicks;

		public bool active;

		public string mode = "1v1";

		public string phase = "idle";

		public int size;

		public int bracketSize;

		public int currentRound;

		public List<TournamentEntrant> entrants = new List<TournamentEntrant>();

		public List<TournamentMatch> matches = new List<TournamentMatch>();

		public string championId = "";

		public string championLabel = "";

		public int seasonId = 1;

		public string eliminationType = "single";

		public int totalRounds;

		public TournamentEntrant Find(string id)
		{
			return entrants.Find((TournamentEntrant e) => e != null && e.entrantId == id);
		}

		public TournamentMatch ActiveMatchBetween(string x, string y)
		{
			foreach (TournamentMatch match in matches)
			{
				if (match.round == currentRound && string.IsNullOrEmpty(match.winnerId) && ((match.aId == x && match.bId == y) || (match.aId == y && match.bId == x)))
				{
					return match;
				}
			}
			return null;
		}
	}
	[Serializable]
	public class TournamentBook
	{
		public List<TournamentState> tournaments = new List<TournamentState>();

		public TournamentState Get(string key)
		{
			return tournaments.Find((TournamentState t) => t != null && (t.key ?? "") == (key ?? ""));
		}

		public TournamentState ForEntrant(string entrantId)
		{
			if (string.IsNullOrEmpty(entrantId))
			{
				return null;
			}
			foreach (TournamentState tournament in tournaments)
			{
				if (tournament != null && tournament.Find(entrantId) != null)
				{
					return tournament;
				}
			}
			return null;
		}
	}
	[Serializable]
	public class ChampionRecord
	{
		public string mode;

		public string championLabel;

		public string ownerName;

		public int bracketSize;

		public int seasonId;

		public long dateTicks;
	}
	[Serializable]
	public class ChampionsData
	{
		public List<ChampionRecord> champions = new List<ChampionRecord>();
	}
	public static class TournamentService
	{
		private static TournamentBook _book = new TournamentBook();

		private static TournamentBook _snapshot = new TournamentBook();

		public const string FreeSlot = "";

		public const string CoinSlot = "coins";

		public const string ValcoinSlot = "valcoin";

		public static float MatchTimeoutSeconds = 0f;

		private const double CompletionGraceSeconds = 6.0;

		public static TournamentBook Snapshot => _snapshot;

		public static IEnumerable<TournamentState> All => (_snapshot?.tournaments ?? new List<TournamentState>()).Where((TournamentState t) => t?.active ?? false);

		public static bool AnyActive => All.Any();

		public static TournamentState Legacy => Get("");

		public static TournamentState Get(string key)
		{
			return _snapshot?.Get(key ?? "");
		}

		public static TournamentState FindByEntrant(string entrantId)
		{
			return _snapshot?.ForEntrant(entrantId);
		}

		private static string StatePath()
		{
			return Path.Combine(LeaderboardStore.DataDir(), "tournament." + LeaderboardStore.WorldTag() + ".json");
		}

		private static string ChampionsPath()
		{
			return Path.Combine(LeaderboardStore.DataDir(), "champions." + LeaderboardStore.WorldTag() + ".json");
		}

		public static void LoadForCurrentWorld()
		{
			try
			{
				string path = StatePath();
				if (File.Exists(path))
				{
					_book = CompetitiveJson.ReadTournamentBook(File.ReadAllText(path)) ?? new TournamentBook();
					if (_book.tournaments == null)
					{
						_book.tournaments = new List<TournamentState>();
					}
					foreach (TournamentState tournament in _book.tournaments)
					{
						if (tournament != null)
						{
							if (tournament.entrants == null)
							{
								tournament.entrants = new List<TournamentEntrant>();
							}
							if (tournament.matches == null)
							{
								tournament.matches = new List<TournamentMatch>();
							}
						}
					}
					Plugin.Log.LogInfo((object)($"[tourney] resumed {_book.tournaments.Count} tournament slot(s): " + string.Join(", ", _book.tournaments.Select((TournamentState t) => $"'{t.key}':{t.phase}/{t.entrants.Count}"))));
				}
				else
				{
					_book = new TournamentBook();
				}
			}
			catch (Exception ex)
			{
				_book = new TournamentBook();
				Plugin.Log.LogWarning((object)("[tourney] load failed: " + ex.Message));
			}
			_snapshot = _book;
		}

		private static void Save()
		{
			try
			{
				File.WriteAllText(StatePath(), CompetitiveJson.Write(_book, pretty: true));
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[tourney] save failed: " + ex.Message));
			}
		}

		public static string SerializeSnapshot()
		{
			return CompetitiveJson.Write(_book ?? new TournamentBook());
		}

		public static void SerializerSelfTest()
		{
			try
			{
				TournamentState tournamentState = new TournamentState
				{
					key = "valcoin",
					currency = "valcoin",
					active = true,
					mode = "1v1",
					phase = "registration",
					size = 4,
					entryFee = 10
				};
				tournamentState.entrants.Add(new TournamentEntrant
				{
					entrantId = "probe-id",
					ownerId = 42L,
					ownerName = "probe",
					label = "Probe",
					level = 3,
					feePaid = 10
				});
				tournamentState.matches.Add(new TournamentMatch
				{
					round = 1,
					aId = "probe-id",
					aLabel = "Probe"
				});
				string text = CompetitiveJson.Write(new TournamentBook
				{
					tournaments = { tournamentState }
				});
				TournamentBook tournamentBook = CompetitiveJson.ReadTournamentBook(text);
				TournamentState tournamentState2 = tournamentBook?.Get("valcoin");
				bool flag = text.Contains("entrantId");
				Plugin.Log.LogInfo((object)($"[tourney] serializer self-test: jsonHasLists={flag}, " + $"slots={tournamentBook?.tournaments?.Count ?? (-1)}, entrants={tournamentState2?.entrants?.Count ?? (-1)}, " + $"matches={tournamentState2?.matches?.Count ?? (-1)}, fee={tournamentState2?.entryFee ?? (-1)}, jsonLen={text.Length}."));
				if (!flag || tournamentState2 == null || tournamentState2.entrants.Count != 1 || tournamentState2.matches.Count != 1 || tournamentState2.entryFee != 10)
				{
					Plugin.Log.LogWarning((object)("[tourney] serializer self-test FAILED — data is being dropped. json=" + text));
				}
			}
			catch (Exception arg)
			{
				Plugin.Log.LogWarning((object)$"[tourney] serializer self-test threw: {arg}");
			}
		}

		public static void ApplySnapshot(string json)
		{
			try
			{
				TournamentBook tournamentBook = CompetitiveJson.ReadTournamentBook(json) ?? new TournamentBook();
				if (tournamentBook.tournaments == null)
				{
					tournamentBook.tournaments = new List<TournamentState>();
				}
				foreach (TournamentState tournament in tournamentBook.tournaments)
				{
					if (tournament != null)
					{
						if (tournament.entrants == null)
						{
							tournament.entrants = new List<TournamentEntrant>();
						}
						if (tournament.matches == null)
						{
							tournament.matches = new List<TournamentMatch>();
						}
					}
				}
				_snapshot = tournamentBook;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[tourney] snapshot apply failed: " + ex.Message));
			}
		}

		private static TournamentState Live(string key)
		{
			return _book?.Get(key ?? "");
		}

		private static TournamentState LiveForEntrant(string entrantId)
		{
			return _book?.ForEntrant(entrantId);
		}

		private static void Put(TournamentState s)
		{
			if (s != null)
			{
				TournamentState tournamentState = _book.Get(s.key);
				if (tournamentState != null)
				{
					_book.tournaments.Remove(tournamentState);
				}
				_book.tournaments.Add(s);
			}
		}

		private static void Drop(string key)
		{
			TournamentState tournamentState = _book.Get(key ?? "");
			if (tournamentState != null)
			{
				_book.tournaments.Remove(tournamentState);
			}
		}

		public static string Start(string mode, int size, string eliminationType = "single")
		{
			mode = (mode ?? "1v1").ToLowerInvariant();
			if (mode != "1v1" && mode != "party")
			{
				return "mode must be 1v1 or party.";
			}
			eliminationType = (eliminationType ?? "single").ToLowerInvariant();
			if (eliminationType != "single" && eliminationType != "double" && eliminationType != "round_robin")
			{
				return "elimination type must be single, double, or round_robin.";
			}
			TournamentState tournamentState = Live("");
			if (tournamentState != null && tournamentState.active)
			{
				return "a tournament is already running — cancel it first.";
			}
			int num = Mathf.Max(1, Plugin.MaxEntrants.Value);
			int num2 = ((size <= 0) ? num : Mathf.Min(size, num));
			Put(new TournamentState
			{
				key = "",
				active = true,
				mode = mode,
				phase = "registration",
				size = num2,
				eliminationType = eliminationType,
				seasonId = 1,
				openedTicks = DateTime.UtcNow.Ticks
			});
			Save();
			Broadcast();
			Announce($"\ud83c\udfdf\ufe0f A **{mode}** tournament ({DisplayType(eliminationType)}) is open for registration — {num2} slots. " + "Seal a companion into a Communion Totem and enter from the Tournament panel (F7).");
			return $"Tournament ({mode}, {eliminationType}) open for registration — {num2} slots.";
		}

		public static void StartWagered(WagerCurrency currency, long hostId, string hostName, Action<bool, string> done)
		{
			string key = Wager.Key(currency);
			if (currency != WagerCurrency.Coins && currency != WagerCurrency.Valcoin)
			{
				done?.Invoke(arg1: false, "Unknown currency.");
				return;
			}
			if (!WagerService.IsAvailable(currency, out var reason))
			{
				done?.Invoke(arg1: false, reason);
				return;
			}
			TournamentState tournamentState = Live(key);
			if (tournamentState != null && tournamentState.active)
			{
				done?.Invoke(arg1: false, "A " + Wager.Display(currency) + " tournament is already running — only one at a time.");
				return;
			}
			int fee = Wager.TournamentFee(currency);
			int size = Mathf.Max(2, Plugin.WageredBracketSize.Value);
			WagerService.Charge(currency, hostName, fee, "ls_tourney_entry", "opened a " + Wager.Display(currency) + " tournament", CoinsAlreadyPaid(currency, fee), delegate(bool ok, string msg)
			{
				if (!ok)
				{
					done?.Invoke(arg1: false, msg ?? "The stake could not be taken.");
				}
				else
				{
					TournamentState tournamentState2 = new TournamentState
					{
						key = key,
						currency = key,
						entryFee = fee,
						prize = Wager.TournamentPrize(currency),
						hostId = hostId,
						hostName = (hostName ?? string.Empty),
						hostCredit = fee,
						active = true,
						mode = "1v1",
						phase = "registration",
						size = size,
						eliminationType = "single",
						seasonId = 1,
						openedTicks = DateTime.UtcNow.Ticks
					};
					Put(tournamentState2);
					Save();
					Broadcast();
					Announce($"\ud83c\udfdf\ufe0f **{hostName}** has opened a **{size}-player {Wager.Display(currency)} tournament**! " + $"Entry: **{fee} {Wager.Display(currency)}** · Champion's purse: **{tournamentState2.prize} {Wager.Display(currency)}**. " + "Seal a companion into a Communion Totem and enter from the Tournament panel (F7) — the bracket starts the moment it fills.");
					Plugin.Log.LogInfo((object)$"[tourney] {hostName} opened the {key} tournament ({fee} fee, {size} slots).");
					done?.Invoke(arg1: true, $"Your {Wager.Display(currency)} tournament is open — {size} slots. " + "Lock your own totem to claim your place; your entry is already paid.");
				}
			});
		}

		private static int CoinsAlreadyPaid(WagerCurrency c, int fee)
		{
			if (c != WagerCurrency.Coins)
			{
				return 0;
			}
			return fee;
		}

		public static void Join(string key, string entrantId, long ownerId, string ownerName, string label, int caste, int seedRating, string totemPayload, List<string> teamPayloads, int level, int clientPaidCoins, Action<bool, string> done)
		{
			TournamentState s = Live(key);
			if (s == null || !s.active || s.phase != "registration")
			{
				done?.Invoke(arg1: false, "no tournament is accepting entries.");
				return;
			}
			if (string.IsNullOrEmpty(entrantId))
			{
				done?.Invoke(arg1: false, "could not identify your entry.");
				return;
			}
			if (s.Find(entrantId) != null)
			{
				done?.Invoke(arg1: false, "already registered.");
				return;
			}
			if (s.size > 0 && s.entrants.Count >= s.size)
			{
				done?.Invoke(arg1: false, "the tournament is full.");
				return;
			}
			if (s.entrants.Any((TournamentEntrant e) => e.ownerId == ownerId))
			{
				done?.Invoke(arg1: false, "you already have an entry in this tournament.");
				return;
			}
			int value = Plugin.RequiredEntrantLevel.Value;
			if (value > 0 && caste >= 0 && level != value)
			{
				done?.Invoke(arg1: false, $"only Level {value} companions may enter this tournament.");
				return;
			}
			if (s.entryFee <= 0)
			{
				Register(0);
				return;
			}
			if (ownerId == s.hostId && s.hostCredit > 0)
			{
				int hostCredit = s.hostCredit;
				s.hostCredit = 0;
				Register(hostCredit, fromHostCredit: true);
				return;
			}
			WagerService.Charge(Wager.Parse(s.currency), ownerName, s.entryFee, "ls_tourney_entry", "tournament entry", clientPaidCoins, delegate(bool ok, string msg)
			{
				if (!ok)
				{
					done?.Invoke(arg1: false, msg ?? "The entry fee could not be taken.");
				}
				else
				{
					Register(s.entryFee);
				}
			});
			void Register(int feePaid, bool fromHostCredit = false)
			{
				if (Live(key) != s || !s.active || s.phase != "registration" || (s.size > 0 && s.entrants.Count >= s.size) || s.entrants.Any((TournamentEntrant e) => e.ownerId == ownerId))
				{
					if (fromHostCredit)
					{
						s.hostCredit = feePaid;
						done?.Invoke(arg1: false, "Your entry could not be placed — your paid slot is still held.");
					}
					else
					{
						if (feePaid > 0)
						{
							WagerService.RollBackOwnCharge(Wager.Parse(s.currency), ownerId, ownerName, feePaid, "the tournament closed before your entry landed");
						}
						done?.Invoke(arg1: false, "The tournament closed before your entry landed — your stake is returned.");
					}
				}
				else
				{
					s.entrants.Add(new TournamentEntrant
					{
						entrantId = entrantId,
						ownerId = ownerId,
						ownerName = ownerName,
						label = label,
						caste = caste,
						seedRating = seedRating,
						level = level,
						totemPayload = (totemPayload ?? string.Empty),
						teamPayloads = (teamPayloads ?? new List<string>()),
						feePaid = feePaid
					});
					Save();
					Broadcast();
					if (s.entryFee > 0)
					{
						Announce("⚔\ufe0f **" + ownerName + "** enters the " + Wager.Display(Wager.Parse(s.currency)) + " tournament with **" + label + "**" + ((level > 0) ? $" (Lv{level})" : "") + $" — {s.entrants.Count}/{s.size} entered.");
					}
					done?.Invoke(arg1: true, $"Registered '{label}' ({s.entrants.Count}" + ((s.size > 0) ? $"/{s.size}" : "") + ").");
					if (s.entryFee > 0 && s.size > 0 && s.entrants.Count >= s.size)
					{
						Begin(key);
					}
				}
			}
		}

		public static List<string> PayloadsOf(TournamentEntrant e)
		{
			List<string> list = new List<string>();
			if (e == null)
			{
				return list;
			}
			if (!string.IsNullOrEmpty(e.totemPayload))
			{
				list.Add(e.totemPayload);
			}
			if (e.teamPayloads != null)
			{
				list.AddRange(e.teamPayloads.Where((string p) => !string.IsNullOrEmpty(p)));
			}
			return list;
		}

		public static List<string> Withdraw(string key, long ownerId, out string status)
		{
			status = "no tournament is accepting entries.";
			TournamentState tournamentState = Live(key);
			if (tournamentState == null || !tournamentState.active || tournamentState.phase != "registration")
			{
				return new List<string>();
			}
			TournamentEntrant tournamentEntrant = tournamentState.entrants.FirstOrDefault((TournamentEntrant e) => e.ownerId == ownerId);
			if (tournamentEntrant == null)
			{
				status = "you have no entry to withdraw.";
				return new List<string>();
			}
			List<string> result = PayloadsOf(tournamentEntrant);
			tournamentState.entrants.Remove(tournamentEntrant);
			RefundEntrant(tournamentState, tournamentEntrant, "withdrew from the tournament");
			Save();
			Broadcast();
			status = ((tournamentEntrant.feePaid > 0) ? $"Withdrew '{tournamentEntrant.label}'. Your companion totem and {tournamentEntrant.feePaid} {Wager.Display(Wager.Parse(tournamentState.currency))} are returned." : ("Withdrew '" + tournamentEntrant.label + "'. Your companion totem is returned."));
			return result;
		}

		public static List<string> ReleaseEntrant(string key, string idOrName, out long ownerId, out string status)
		{
			ownerId = 0L;
			status = "no tournament is running.";
			TournamentState tournamentState = Live(key);
			if (tournamentState == null || !tournamentState.active)
			{
				return new List<string>();
			}
			TournamentEntrant tournamentEntrant = tournamentState.entrants.FirstOrDefault((TournamentEntrant e) => e.entrantId == idOrName || string.Equals(e.ownerName, idOrName, StringComparison.OrdinalIgnoreCase) || string.Equals(e.label, idOrName, StringComparison.OrdinalIgnoreCase));
			if (tournamentEntrant == null)
			{
				status = "no entrant '" + idOrName + "'.";
				return new List<string>();
			}
			ownerId = tournamentEntrant.ownerId;
			List<string> result = PayloadsOf(tournamentEntrant);
			if (tournamentState.phase == "registration")
			{
				tournamentState.entrants.Remove(tournamentEntrant);
				RefundEntrant(tournamentState, tournamentEntrant, "released from the tournament");
			}
			else
			{
				tournamentEntrant.eliminated = true;
				foreach (TournamentMatch match in tournamentState.matches)
				{
					if (match.round == tournamentState.currentRound && string.IsNullOrEmpty(match.winnerId) && (match.aId == tournamentEntrant.entrantId || match.bId == tournamentEntrant.entrantId))
					{
						string text = ((match.aId == tournamentEntrant.entrantId) ? match.bId : match.aId);
						if (!string.IsNullOrEmpty(text))
						{
							ResolveMatch(tournamentState, match, text);
						}
						break;
					}
				}
				tournamentEntrant.totemPayload = string.Empty;
				tournamentEntrant.teamPayloads = new List<string>();
			}
			Save();
			Broadcast();
			status = "Released '" + tournamentEntrant.label + "' — totem returned to " + tournamentEntrant.ownerName + ".";
			return result;
		}

		public static Dictionary<long, List<string>> DrainAllEscrow(string key)
		{
			Dictionary<long, List<string>> dictionary = new Dictionary<long, List<string>>();
			TournamentState tournamentState = Live(key);
			if (tournamentState == null)
			{
				return dictionary;
			}
			foreach (TournamentEntrant entrant in tournamentState.entrants)
			{
				List<string> list = PayloadsOf(entrant);
				if (list.Count != 0)
				{
					if (!dictionary.TryGetValue(entrant.ownerId, out var value))
					{
						value = new List<string>();
						dictionary[entrant.ownerId] = value;
					}
					value.AddRange(list);
					entrant.totemPayload = string.Empty;
					entrant.teamPayloads = new List<string>();
				}
			}
			return dictionary;
		}

		public static string Begin(string key)
		{
			TournamentState tournamentState = Live(key);
			if (tournamentState == null || !tournamentState.active || tournamentState.phase != "registration")
			{
				return "no tournament is in registration.";
			}
			if (tournamentState.entrants.Count < 2)
			{
				return "need at least 2 entrants.";
			}
			tournamentState.phase = "running";
			tournamentState.bracketSize = tournamentState.entrants.Count;
			tournamentState.currentRound = 1;
			tournamentState.matches.Clear();
			List<string> list = tournamentState.entrants.Select((TournamentEntrant e) => e.entrantId).ToList();
			string eliminationType = tournamentState.eliminationType;
			if (!(eliminationType == "round_robin"))
			{
				if (eliminationType == "double")
				{
					BuildDoubleRound(tournamentState, 1);
				}
				else
				{
					BuildRound(tournamentState, list, 1);
				}
			}
			else
			{
				BuildRoundRobinSchedule(tournamentState, list);
			}
			Save();
			Broadcast();
			Announce($"\ud83d\udd14 The {Label(tournamentState)} bracket is set — **{tournamentState.entrants.Count} entrants**, round 1 begins!" + ((tournamentState.entryFee > 0) ? " Each pair fights wherever they choose: both owners open the Tournament panel (F7) and press **Ready to Fight** once they have met up." : ""));
			AnnounceRoundMatches(tournamentState, 1);
			return $"Tournament begun ({tournamentState.eliminationType}) — {tournamentState.entrants.Count} entrants, round 1.";
		}

		public static string Cancel(string key)
		{
			TournamentState tournamentState = Live(key);
			if (tournamentState == null || !tournamentState.active)
			{
				return "no tournament is running.";
			}
			LeaderboardSync.ReturnEscrowToOwners(DrainAllEscrow(key));
			RefundEveryone(tournamentState, "the tournament was cancelled");
			string text = Label(tournamentState);
			Drop(key);
			Save();
			Broadcast();
			Announce("\ud83d\udeab The " + text + " has been cancelled — every companion totem and stake has been returned.");
			return "Tournament cancelled — companion totems and stakes returned.";
		}

		public static string Forfeit(string key, string playerName)
		{
			TournamentState tournamentState = Live(key);
			if (tournamentState == null || !tournamentState.active || tournamentState.phase != "running")
			{
				return "no tournament round is running.";
			}
			TournamentEntrant tournamentEntrant = tournamentState.entrants.FirstOrDefault((TournamentEntrant e) => string.Equals(e.ownerName, playerName, StringComparison.OrdinalIgnoreCase));
			if (tournamentEntrant == null)
			{
				return "'" + playerName + "' is not an entrant.";
			}
			foreach (TournamentMatch match in tournamentState.matches)
			{
				if (match.round == tournamentState.currentRound && string.IsNullOrEmpty(match.winnerId) && (match.aId == tournamentEntrant.entrantId || match.bId == tournamentEntrant.entrantId))
				{
					string text = ((match.aId == tournamentEntrant.entrantId) ? match.bId : match.aId);
					if (string.IsNullOrEmpty(text))
					{
						return "opponent not set — cannot forfeit a bye.";
					}
					Announce("\ud83c\udff3\ufe0f **" + tournamentEntrant.ownerName + "** forfeits in the " + Label(tournamentState) + ".");
					ResolveMatch(tournamentState, match, text);
					return playerName + " forfeits — opponent advances.";
				}
			}
			return playerName + " has no undecided match this round.";
		}

		public static string ActivateCurrentRound(string key)
		{
			TournamentState tournamentState = Live(key);
			if (tournamentState == null || !tournamentState.active || tournamentState.phase != "running")
			{
				return "no tournament round is running.";
			}
			int num = 0;
			foreach (TournamentMatch item in tournamentState.matches.ToList())
			{
				if (item.round == tournamentState.currentRound && string.IsNullOrEmpty(item.winnerId) && !string.IsNullOrEmpty(item.bId) && ActivateMatch(tournamentState, item))
				{
					num++;
				}
			}
			Save();
			Broadcast();
			if (num != 0)
			{
				return $"Activated {num} match(es) — companions summoned to duel.";
			}
			return "No pairings to activate this round.";
		}

		public static string SetReady(string key, long ownerId)
		{
			TournamentState tournamentState = Live(key);
			if (tournamentState == null || !tournamentState.active || tournamentState.phase != "running")
			{
				return "no tournament round is running.";
			}
			TournamentEntrant tournamentEntrant = tournamentState.entrants.FirstOrDefault((TournamentEntrant e) => e.ownerId == ownerId);
			if (tournamentEntrant == null)
			{
				return "you are not in this tournament.";
			}
			foreach (TournamentMatch match in tournamentState.matches)
			{
				if (match.round != tournamentState.currentRound || !string.IsNullOrEmpty(match.winnerId) || match.activated)
				{
					continue;
				}
				bool flag = match.aId == tournamentEntrant.entrantId;
				bool flag2 = match.bId == tournamentEntrant.entrantId;
				if (flag || flag2)
				{
					if (string.IsNullOrEmpty(match.bId))
					{
						return "you have a bye this round.";
					}
					if (flag)
					{
						match.aReady = true;
					}
					else
					{
						match.bReady = true;
					}
					Save();
					Broadcast();
					if (match.aReady && match.bReady)
					{
						ActivateMatch(tournamentState, match);
						Save();
						Broadcast();
						return "Both fighters are ready — the duel begins!";
					}
					return "Ready. Waiting for " + (tournamentState.Find(flag ? match.bId : match.aId)?.ownerName ?? "your opponent") + " to be ready too.";
				}
			}
			return "you have no match awaiting a start this round.";
		}

		private static bool ActivateMatch(TournamentState s, TournamentMatch m)
		{
			if (m == null || m.activated || !string.IsNullOrEmpty(m.winnerId) || string.IsNullOrEmpty(m.bId))
			{
				return false;
			}
			TournamentEntrant tournamentEntrant = s.Find(m.aId);
			TournamentEntrant tournamentEntrant2 = s.Find(m.bId);
			if (tournamentEntrant == null || tournamentEntrant2 == null)
			{
				return false;
			}
			m.activated = true;
			LeaderboardSync.SummonForMatch(tournamentEntrant.ownerId, tournamentEntrant.entrantId, s.mode, tournamentEntrant2.entrantId, tournamentEntrant2.label, s.currentRound, PayloadsOf(tournamentEntrant));
			LeaderboardSync.SummonForMatch(tournamentEntrant2.ownerId, tournamentEntrant2.entrantId, s.mode, tournamentEntrant.entrantId, tournamentEntrant.label, s.currentRound, PayloadsOf(tournamentEntrant2));
			Announce($"\ud83e\udd4a **Round {s.currentRound} — the duel is on:** {tournamentEntrant.label} ({tournamentEntrant.ownerName}) vs {tournamentEntrant2.label} ({tournamentEntrant2.ownerName}) " + "in the " + Label(s) + ".");
			return true;
		}

		public static void UpdateEscrow(string entrantId, List<string> payloads)
		{
			TournamentState tournamentState = LiveForEntrant(entrantId);
			TournamentEntrant tournamentEntrant = tournamentState?.Find(entrantId);
			if (tournamentEntrant != null && payloads != null && payloads.Count != 0)
			{
				if (tournamentState.mode == "party")
				{
					tournamentEntrant.teamPayloads = payloads;
				}
				else
				{
					tournamentEntrant.totemPayload = payloads[0];
				}
				Save();
				Plugin.Log.LogInfo((object)$"[tourney] escrow updated for '{tournamentEntrant.label}' ({payloads.Count} totem(s)).");
			}
		}

		public static TournamentEntrant FindEntrant(string entrantId)
		{
			return LiveForEntrant(entrantId)?.Find(entrantId);
		}

		public static void NotifyDuelResult(string winnerCompanionId, string loserCompanionId)
		{
			foreach (TournamentState item in _book.tournaments.ToList())
			{
				if (item != null && item.active && !(item.phase != "running") && !(item.mode != "1v1"))
				{
					TournamentMatch tournamentMatch = item.ActiveMatchBetween(winnerCompanionId, loserCompanionId);
					if (tournamentMatch != null)
					{
						ResolveMatch(item, tournamentMatch, winnerCompanionId);
						break;
					}
				}
			}
		}

		public static void NotifyPartyResult(long winnerOwnerId, long loserOwnerId)
		{
			foreach (TournamentState item in _book.tournaments.ToList())
			{
				if (item != null && item.active && !(item.phase != "running") && !(item.mode != "party"))
				{
					TournamentMatch tournamentMatch = item.ActiveMatchBetween(winnerOwnerId.ToString(), loserOwnerId.ToString());
					if (tournamentMatch != null)
					{
						ResolveMatch(item, tournamentMatch, winnerOwnerId.ToString());
						break;
					}
				}
			}
		}

		public static void Tick()
		{
			if (_book?.tournaments == null)
			{
				return;
			}
			foreach (TournamentState item in _book.tournaments.ToList())
			{
				if (item != null && item.active && !(item.phase != "complete") && item.completedTicks > 0 && !((DateTime.UtcNow - new DateTime(item.completedTicks, DateTimeKind.Utc)).TotalSeconds < 6.0))
				{
					LeaderboardSync.ReturnEscrowToOwners(DrainAllEscrow(item.key));
					item.completedTicks = 0L;
					if (item.entryFee > 0)
					{
						Drop(item.key);
					}
					Save();
					Broadcast();
				}
			}
			float value = Plugin.WageredRegistrationMinutes.Value;
			if (value <= 0f)
			{
				return;
			}
			foreach (TournamentState item2 in _book.tournaments.ToList())
			{
				if (item2 != null && item2.active && !(item2.phase != "registration") && item2.entryFee > 0 && item2.openedTicks > 0 && !((DateTime.UtcNow - new DateTime(item2.openedTicks, DateTimeKind.Utc)).TotalMinutes < (double)value))
				{
					Plugin.Log.LogInfo((object)$"[tourney] '{item2.key}' expired with {item2.entrants.Count}/{item2.size} entrants — refunding.");
					Announce($"⌛ The {Label(item2)} never filled ({item2.entrants.Count}/{item2.size}) and has been cancelled. " + "Every stake is refunded and every companion totem returned.");
					LeaderboardSync.ReturnEscrowToOwners(DrainAllEscrow(item2.key));
					RefundEveryone(item2, "the tournament never filled");
					Drop(item2.key);
					Save();
					Broadcast();
				}
			}
		}

		private static void RefundEntrant(TournamentState s, TournamentEntrant e, string why)
		{
			if (s != null && e != null && e.feePaid > 0)
			{
				WagerService.Refund(Wager.Parse(s.currency), e.ownerId, e.ownerName, e.feePaid, why);
				e.feePaid = 0;
			}
		}

		private static void RefundEveryone(TournamentState s, string why)
		{
			if (s == null)
			{
				return;
			}
			foreach (TournamentEntrant entrant in s.entrants)
			{
				RefundEntrant(s, entrant, why);
			}
			if (s.hostCredit > 0)
			{
				WagerService.Refund(Wager.Parse(s.currency), s.hostId, s.hostName, s.hostCredit, why);
				s.hostCredit = 0;
			}
		}

		private static void ResolveMatch(TournamentState s, TournamentMatch m, string winnerId)
		{
			m.winnerId = winnerId;
			string id = ((m.aId == winnerId) ? m.bId : m.aId);
			TournamentEntrant tournamentEntrant = s.Find(id);
			TournamentEntrant tournamentEntrant2 = s.Find(winnerId);
			if (tournamentEntrant2 != null)
			{
				tournamentEntrant2.wins++;
			}
			if (!string.IsNullOrEmpty(m.bId) && tournamentEntrant2 != null)
			{
				Announce("\ud83c\udfc5 **" + tournamentEntrant2.label + "** (" + tournamentEntrant2.ownerName + ") defeats **" + (tournamentEntrant?.label ?? "their rival") + "**" + ((tournamentEntrant != null) ? (" (" + tournamentEntrant.ownerName + ")") : "") + $" in round {m.round} of the {Label(s)}.");
			}
			string eliminationType = s.eliminationType;
			if (!(eliminationType == "round_robin"))
			{
				if (eliminationType == "double")
				{
					ResolveDoubleMatch(s, m, tournamentEntrant2, tournamentEntrant);
				}
				else
				{
					ResolveSingleMatch(s, m, tournamentEntrant2, tournamentEntrant);
				}
			}
			else
			{
				ResolveRoundRobinMatch(s, m, tournamentEntrant2, tournamentEntrant);
			}
		}

		private static void ResolveSingleMatch(TournamentState s, TournamentMatch m, TournamentEntrant winnerEnt, TournamentEntrant loser)
		{
			if (loser != null)
			{
				loser.eliminated = true;
				loser.losses++;
			}
			Plugin.Log.LogInfo((object)$"[tourney] round {m.round}: '{winnerEnt?.label}' beat '{loser?.label}'.");
			Save();
			Broadcast();
			if (s.matches.Where((TournamentMatch x) => x.round == s.currentRound).All((TournamentMatch x) => !string.IsNullOrEmpty(x.winnerId)))
			{
				List<string> list = (from x in s.matches
					where x.round == s.currentRound
					select x.winnerId into id
					where !string.IsNullOrEmpty(id)
					select id).ToList();
				if (list.Count <= 1)
				{
					Complete(s, (list.Count == 1) ? list[0] : winnerEnt?.entrantId);
					return;
				}
				s.currentRound++;
				BuildRound(s, list, s.currentRound);
				Save();
				Broadcast();
				AnnounceRoundMatches(s, s.currentRound);
			}
			else
			{
				AnnounceStillToFight(s);
			}
		}

		private static void ResolveRoundRobinMatch(TournamentState s, TournamentMatch m, TournamentEntrant winnerEnt, TournamentEntrant loser)
		{
			Plugin.Log.LogInfo((object)$"[tourney] round {m.round} (round robin): '{winnerEnt?.label}' beat '{loser?.label}'.");
			Save();
			Broadcast();
			if (!s.matches.Where((TournamentMatch x) => x.round == s.currentRound).All((TournamentMatch x) => !string.IsNullOrEmpty(x.winnerId)))
			{
				AnnounceStillToFight(s);
			}
			else if (s.currentRound >= s.totalRounds)
			{
				TournamentEntrant tournamentEntrant = (from e in s.entrants
					orderby e.wins descending, e.seedRating descending, e.label
					select e).FirstOrDefault();
				if (tournamentEntrant != null)
				{
					Complete(s, tournamentEntrant.entrantId);
				}
			}
			else
			{
				s.currentRound++;
				Save();
				Broadcast();
				AnnounceRoundMatches(s, s.currentRound);
			}
		}

		private static void ResolveDoubleMatch(TournamentState s, TournamentMatch m, TournamentEntrant winnerEnt, TournamentEntrant loser)
		{
			if (loser != null)
			{
				loser.losses++;
				if (loser.losses >= 2)
				{
					loser.eliminated = true;
				}
			}
			Plugin.Log.LogInfo((object)$"[tourney] round {m.round} ({m.bracket}): '{winnerEnt?.label}' beat '{loser?.label}' (losses={loser?.losses ?? 0}).");
			Save();
			Broadcast();
			if (!s.matches.Where((TournamentMatch x) => x.round == s.currentRound).All((TournamentMatch x) => !string.IsNullOrEmpty(x.winnerId)))
			{
				AnnounceStillToFight(s);
				return;
			}
			if (m.bracket == "GF")
			{
				Complete(s, winnerEnt?.entrantId);
				return;
			}
			s.currentRound++;
			BuildDoubleRound(s, s.currentRound);
			Save();
			Broadcast();
			AnnounceRoundMatches(s, s.currentRound);
		}

		private static void Complete(TournamentState s, string championId)
		{
			s.phase = "complete";
			s.championId = championId;
			TournamentEntrant tournamentEntrant = s.Find(championId);
			s.championLabel = tournamentEntrant?.label ?? championId;
			Save();
			Broadcast();
			Plugin.Log.LogInfo((object)("[tourney] '" + s.key + "' complete — champion: " + s.championLabel + "."));
			ArchiveChampion(s, tournamentEntrant);
			if (tournamentEntrant != null)
			{
				LeaderboardSync.SendTournamentWon(tournamentEntrant.ownerName, s.mode, s.bracketSize, tournamentEntrant.caste);
				Announce("\ud83c\udfc6 **" + tournamentEntrant.ownerName + "** is the champion of the " + Label(s) + " with **" + tournamentEntrant.label + "**" + ((tournamentEntrant.level > 0) ? $" (Lv{tournamentEntrant.level})" : "") + "!");
				PayChampion(s, tournamentEntrant);
			}
			AnnounceSummary(s, tournamentEntrant);
			s.completedTicks = DateTime.UtcNow.Ticks;
			Save();
			Broadcast();
		}

		private static void PayChampion(TournamentState s, TournamentEntrant champ)
		{
			if (s.prize > 0 && champ != null)
			{
				switch (Wager.Parse(s.currency))
				{
				case WagerCurrency.Coins:
					WagerService.Pay(WagerCurrency.Coins, champ.ownerId, champ.ownerName, s.prize, "ls_tourney_entry", "tournament champion");
					break;
				case WagerCurrency.Valcoin:
					LeaderboardSync.SendTournamentPrize(champ.ownerName, s.currency, s.prize);
					break;
				}
			}
		}

		private static void BuildRound(TournamentState s, List<string> survivorIds, int round)
		{
			List<TournamentEntrant> ents = (from id in survivorIds
				select s.Find(id) into e
				where e != null
				orderby e.seedRating descending, e.label
				select e).ToList();
			PairPool(s, ents, round, "W");
		}

		private static void PairPool(TournamentState s, List<TournamentEntrant> ents, int round, string bracket)
		{
			int num = 0;
			if (ents.Count % 2 == 1)
			{
				TournamentEntrant tournamentEntrant = ents[0];
				s.matches.Add(new TournamentMatch
				{
					round = round,
					bracket = bracket,
					aId = tournamentEntrant.entrantId,
					aLabel = tournamentEntrant.label,
					aLevel = tournamentEntrant.level,
					bId = "",
					bLabel = "(bye)",
					winnerId = tournamentEntrant.entrantId
				});
				num = 1;
			}
			int num2 = num;
			int num3 = ents.Count - 1;
			while (num2 < num3)
			{
				TournamentEntrant tournamentEntrant2 = ents[num2];
				TournamentEntrant tournamentEntrant3 = ents[num3];
				s.matches.Add(new TournamentMatch
				{
					round = round,
					bracket = bracket,
					aId = tournamentEntrant2.entrantId,
					aLabel = tournamentEntrant2.label,
					aLevel = tournamentEntrant2.level,
					bId = tournamentEntrant3.entrantId,
					bLabel = tournamentEntrant3.label,
					bLevel = tournamentEntrant3.level,
					winnerId = ""
				});
				num2++;
				num3--;
			}
		}

		private static void BuildRoundRobinSchedule(TournamentState s, List<string> ids)
		{
			List<string> list = new List<string>(ids);
			if (list.Count % 2 == 1)
			{
				list.Add("");
			}
			int count = list.Count;
			int num = (s.totalRounds = Mathf.Max(1, count - 1));
			for (int i = 1; i <= num; i++)
			{
				for (int j = 0; j < count / 2; j++)
				{
					string text = list[j];
					string text2 = list[count - 1 - j];
					if (!string.IsNullOrEmpty(text) && !string.IsNullOrEmpty(text2))
					{
						TournamentEntrant tournamentEntrant = s.Find(text);
						TournamentEntrant tournamentEntrant2 = s.Find(text2);
						if (tournamentEntrant != null && tournamentEntrant2 != null)
						{
							s.matches.Add(new TournamentMatch
							{
								round = i,
								bracket = "W",
								aId = text,
								aLabel = tournamentEntrant.label,
								aLevel = tournamentEntrant.level,
								bId = text2,
								bLabel = tournamentEntrant2.label,
								bLevel = tournamentEntrant2.level,
								winnerId = ""
							});
						}
					}
				}
				string value = list[count - 1];
				for (int num2 = count - 1; num2 > 1; num2--)
				{
					list[num2] = list[num2 - 1];
				}
				list[1] = value;
			}
		}

		private static void BuildDoubleRound(TournamentState s, int round)
		{
			List<TournamentEntrant> list = (from e in s.entrants
				where e.losses == 0 && !e.eliminated
				orderby e.seedRating descending, e.label
				select e).ToList();
			List<TournamentEntrant> list2 = (from e in s.entrants
				where e.losses == 1 && !e.eliminated
				orderby e.seedRating descending, e.label
				select e).ToList();
			if (list.Count == 1 && list2.Count == 1)
			{
				TournamentEntrant tournamentEntrant = list[0];
				TournamentEntrant tournamentEntrant2 = list2[0];
				s.matches.Add(new TournamentMatch
				{
					round = round,
					bracket = "GF",
					aId = tournamentEntrant.entrantId,
					aLabel = tournamentEntrant.label,
					aLevel = tournamentEntrant.level,
					bId = tournamentEntrant2.entrantId,
					bLabel = tournamentEntrant2.label,
					bLevel = tournamentEntrant2.level,
					winnerId = ""
				});
			}
			else if (list.Count + list2.Count <= 1)
			{
				TournamentEntrant tournamentEntrant3 = list.Concat(list2).FirstOrDefault();
				if (tournamentEntrant3 != null)
				{
					Complete(s, tournamentEntrant3.entrantId);
				}
			}
			else
			{
				if (list.Count >= 2)
				{
					PairPool(s, list, round, "W");
				}
				if (list2.Count >= 2)
				{
					PairPool(s, list2, round, "L");
				}
			}
		}

		private static void AnnounceRoundMatches(TournamentState s, int round)
		{
			List<string> list = new List<string>();
			foreach (TournamentMatch match in s.matches)
			{
				if (match.round != round)
				{
					continue;
				}
				TournamentEntrant tournamentEntrant = s.Find(match.aId);
				if (string.IsNullOrEmpty(match.bId))
				{
					if (tournamentEntrant != null)
					{
						list.Add("• " + tournamentEntrant.label + " (" + tournamentEntrant.ownerName + ") — bye");
					}
					continue;
				}
				TournamentEntrant tournamentEntrant2 = s.Find(match.bId);
				if (tournamentEntrant != null)
				{
					LeaderboardSync.SendTournamentMatch(tournamentEntrant.ownerName, round, match.bLabel, tournamentEntrant.caste);
				}
				if (tournamentEntrant2 != null)
				{
					LeaderboardSync.SendTournamentMatch(tournamentEntrant2.ownerName, round, match.aLabel, tournamentEntrant2.caste);
				}
				if (tournamentEntrant != null && tournamentEntrant2 != null)
				{
					list.Add("• " + tournamentEntrant.label + " (" + tournamentEntrant.ownerName + ") vs " + tournamentEntrant2.label + " (" + tournamentEntrant2.ownerName + ")");
				}
			}
			if (list.Count != 0)
			{
				Announce($"\ud83d\udccb **{Label(s)} — round {round} draw:**\n" + string.Join("\n", list));
			}
		}

		private static void AnnounceStillToFight(TournamentState s)
		{
			List<TournamentMatch> list = s.matches.Where((TournamentMatch m) => m.round == s.currentRound && string.IsNullOrEmpty(m.winnerId) && !string.IsNullOrEmpty(m.bId)).ToList();
			if (list.Count != 0)
			{
				IEnumerable<string> values = list.Select(delegate(TournamentMatch m)
				{
					TournamentEntrant tournamentEntrant = s.Find(m.aId);
					TournamentEntrant tournamentEntrant2 = s.Find(m.bId);
					return "• " + (tournamentEntrant?.label ?? m.aLabel) + " (" + tournamentEntrant?.ownerName + ") vs " + (tournamentEntrant2?.label ?? m.bLabel) + " (" + tournamentEntrant2?.ownerName + ")";
				});
				Announce($"➡\ufe0f **Still to fight in round {s.currentRound}** of the {Label(s)}:\n" + string.Join("\n", values));
			}
		}

		private static void AnnounceSummary(TournamentState s, TournamentEntrant champ)
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("\ud83d\udcdc **" + Label(s) + " — final summary**\n");
			stringBuilder.Append($"Format: {s.mode} · {DisplayType(s.eliminationType)} · {s.bracketSize} entrants");
			if (s.entryFee > 0)
			{
				stringBuilder.Append($" · entry {s.entryFee} {Wager.Display(Wager.Parse(s.currency))} · purse {s.prize} {Wager.Display(Wager.Parse(s.currency))}");
			}
			stringBuilder.Append('\n');
			if (champ != null)
			{
				stringBuilder.Append("Champion: **" + champ.label + "** (" + champ.ownerName + ")\n");
			}
			stringBuilder.Append("\n__Standings__\n");
			foreach (TournamentEntrant item in from e in s.entrants
				orderby e.wins descending, e.losses, e.label
				select e)
			{
				stringBuilder.Append(string.Format("• {0} ({1}) — {2}W {3}L{4}\n", item.label, item.ownerName, item.wins, item.losses, item.eliminated ? " · out" : ""));
			}
			stringBuilder.Append("\n__Results__\n");
			foreach (TournamentMatch item2 in s.matches.OrderBy((TournamentMatch m) => m.round))
			{
				if (string.IsNullOrEmpty(item2.bId))
				{
					stringBuilder.Append($"• R{item2.round}: {item2.aLabel} — bye\n");
					continue;
				}
				TournamentEntrant tournamentEntrant = s.Find(item2.winnerId);
				stringBuilder.Append($"• R{item2.round}: {item2.aLabel} vs {item2.bLabel}" + ((tournamentEntrant != null) ? (" → **" + tournamentEntrant.label + "**") : " → undecided") + "\n");
			}
			Announce(stringBuilder.ToString());
		}

		private static string Label(TournamentState s)
		{
			if (s == null)
			{
				return "tournament";
			}
			WagerCurrency wagerCurrency = Wager.Parse(s.currency);
			if (wagerCurrency == WagerCurrency.None)
			{
				return "server tournament";
			}
			return Wager.Display(wagerCurrency) + " tournament";
		}

		private static string DisplayType(string t)
		{
			if (!(t == "double"))
			{
				if (t == "round_robin")
				{
					return "round robin";
				}
				return "single elimination";
			}
			return "double elimination";
		}

		private static void Announce(string message)
		{
			ServerGuideBridge.AnnounceDiscord(message);
		}

		private static void ArchiveChampion(TournamentState s, TournamentEntrant champ)
		{
			if (champ == null)
			{
				return;
			}
			try
			{
				string path = ChampionsPath();
				ChampionsData championsData = (File.Exists(path) ? CompetitiveJson.ReadChampions(File.ReadAllText(path)) : new ChampionsData());
				if (championsData.champions == null)
				{
					championsData.champions = new List<ChampionRecord>();
				}
				championsData.champions.Add(new ChampionRecord
				{
					mode = s.mode,
					championLabel = champ.label,
					ownerName = champ.ownerName,
					bracketSize = s.bracketSize,
					seasonId = s.seasonId,
					dateTicks = DateTime.UtcNow.Ticks
				});
				File.WriteAllText(path, CompetitiveJson.Write(championsData, pretty: true));
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[tourney] champion archive failed: " + ex.Message));
			}
		}

		public static List<ChampionRecord> LoadChampions()
		{
			try
			{
				string path = ChampionsPath();
				if (!File.Exists(path))
				{
					return new List<ChampionRecord>();
				}
				return CompetitiveJson.ReadChampions(File.ReadAllText(path))?.champions ?? new List<ChampionRecord>();
			}
			catch
			{
				return new List<ChampionRecord>();
			}
		}

		private static void Broadcast()
		{
			LeaderboardSync.BroadcastTournament();
		}
	}
}
namespace LostScrollsII.Integration
{
	public static class ServerGuideBridge
	{
		private const string ServerGuideGuid = "com.valheimserverguide";

		public static bool IsLoaded => Chainloader.PluginInfos.ContainsKey("com.valheimserverguide");

		public static void AnnounceDiscord(string message)
		{
			if (!IsLoaded || string.IsNullOrEmpty(message) || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			try
			{
				AnnounceDiscordInternal(message);
			}
			catch (Exception arg)
			{
				Plugin.Log.LogWarning((object)$"ServerGuide integration (discord announce) failed: {arg}");
			}
		}

		private static void AnnounceDiscordInternal(string message)
		{
			DiscordAnnouncer.AnnounceRaw(message);
		}

		public static void RaiseTournamentPrize(string currency, int amount)
		{
			if (!IsLoaded)
			{
				return;
			}
			try
			{
				RaiseSimple("dvergr_tournament_prize", currency ?? string.Empty, new Dictionary<string, object>
				{
					{
						"mode",
						currency ?? string.Empty
					},
					{ "bracketSize", amount }
				});
			}
			catch (Exception arg)
			{
				Plugin.Log.LogWarning((object)$"ServerGuide integration (dvergr_tournament_prize) failed: {arg}");
			}
		}

		public static void RaiseRecruited(DvergrCaste caste)
		{
			if (!IsLoaded)
			{
				return;
			}
			try
			{
				RaiseRecruitedInternal(caste);
			}
			catch (Exception arg)
			{
				Plugin.Log.LogWarning((object)$"ServerGuide integration (dvergr_recruited) failed: {arg}");
			}
		}

		public static void RaiseLevelUp(DvergrCaste caste, int level)
		{
			if (!IsLoaded)
			{
				return;
			}
			try
			{
				RaiseLevelUpInternal(caste, level);
			}
			catch (Exception arg)
			{
				Plugin.Log.LogWarning((object)$"ServerGuide integration (dvergr_level_up) failed: {arg}");
			}
		}

		public static void RaiseDuelWon(DvergrCaste winner, DvergrCaste loser, string winnerName = null, string loserName = null)
		{
			if (!IsLoaded)
			{
				return;
			}
			try
			{
				RaiseDuelWonInternal(winner, loser, winnerName, loserName);
			}
			catch (Exception arg)
			{
				Plugin.Log.LogWarning((object)$"ServerGuide integration (dvergr_duel_won) failed: {arg}");
			}
		}

		public static void RaiseRankChanged(int caste, int rank, int rating, string companionName, string ownerName)
		{
			if (!IsLoaded)
			{
				return;
			}
			try
			{
				RaiseRankChangedInternal(caste, rank, rating, companionName, ownerName);
			}
			catch (Exception arg)
			{
				Plugin.Log.LogWarning((object)$"ServerGuide integration (dvergr_rank_changed) failed: {arg}");
			}
		}

		public static void RaiseRankFirst(int caste, int rating, string companionName, string ownerName)
		{
			if (!IsLoaded)
			{
				return;
			}
			try
			{
				DvergrCaste dvergrCaste = (DvergrCaste)caste;
				RaiseSimple("dvergr_rank_first", dvergrCaste.ToString(), new Dictionary<string, object>
				{
					{ "rank", 1 },
					{ "rating", rating },
					{
						"companionName",
						companionName ?? string.Empty
					},
					{
						"ownerName",
						ownerName ?? string.Empty
					}
				});
			}
			catch (Exception arg)
			{
				Plugin.Log.LogWarning((object)$"ServerGuide integration (dvergr_rank_first) failed: {arg}");
			}
		}

		public static void RaisePartyRankFirst(string ownerName, int rating, string partyName)
		{
			if (!IsLoaded)
			{
				return;
			}
			try
			{
				RaiseSimple("dvergr_party_rank_first", ownerName ?? string.Empty, new Dictionary<string, object>
				{
					{ "rank", 1 },
					{ "rating", rating },
					{
						"ownerName",
						ownerName ?? string.Empty
					},
					{
						"partyName",
						string.IsNullOrEmpty(partyName) ? (ownerName ?? string.Empty) : partyName
					}
				});
			}
			catch (Exception arg)
			{
				Plugin.Log.LogWarning((object)$"ServerGuide integration (dvergr_party_rank_first) failed: {arg}");
			}
		}

		public static void RaisePartyDuelWon(string winnerOwnerName, int winSize, string loserOwnerName, int mvpCaste, string partyName = null)
		{
			if (!IsLoaded)
			{
				return;
			}
			try
			{
				RaisePartyDuelWonInternal(winnerOwnerName, winSize, loserOwnerName, mvpCaste, partyName);
			}
			catch (Exception arg)
			{
				Plugin.Log.LogWarning((object)$"ServerGuide integration (dvergr_party_duel_won) failed: {arg}");
			}
		}

		public static void RaisePartyRankChanged(string ownerName, int rank, int rating, string partyName = null)
		{
			if (!IsLoaded)
			{
				return;
			}
			try
			{
				RaisePartyRankChangedInternal(ownerName, rank, rating, partyName);
			}
			catch (Exception arg)
			{
				Plugin.Log.LogWarning((object)$"ServerGuide integration (dvergr_party_rank_changed) failed: {arg}");
			}
		}

		public static void RaiseBountyResolved(int tier, string tierName, string biome, string method)
		{
			if (!IsLoaded)
			{
				return;
			}
			try
			{
				RaiseSimple("dvergr_bounty_resolved", tier.ToString(), new Dictionary<string, object>
				{
					{ "tier", tier },
					{
						"tierName",
						tierName ?? string.Empty
					},
					{
						"bountyBiome",
						biome ?? string.Empty
					},
					{
						"method",
						method ?? string.Empty
					}
				});
			}
			catch (Exception arg)
			{
				Plugin.Log.LogWarning((object)$"ServerGuide integration (dvergr_bounty_resolved) failed: {arg}");
			}
		}

		public static void RaiseBountyValcoin(int tier, string tierName)
		{
			if (!IsLoaded)
			{
				return;
			}
			try
			{
				RaiseSimple("dvergr_bounty_valcoin", tier.ToString(), new Dictionary<string, object>
				{
					{ "tier", tier },
					{
						"tierName",
						tierName ?? string.Empty
					}
				});
			}
			catch (Exception arg)
			{
				Plugin.Log.LogWarning((object)$"ServerGuide integration (dvergr_bounty_valcoin) failed: {arg}");
			}
		}

		public static void RaiseTournamentJoined(string subject)
		{
			if (!IsLoaded)
			{
				return;
			}
			try
			{
				RaiseSimple("dvergr_tournament_joined", subject, null);
			}
			catch (Exception arg)
			{
				Plugin.Log.LogWarning((object)$"ServerGuide integration (dvergr_tournament_joined) failed: {arg}");
			}
		}

		public static void RaiseTournamentMatch(string subject, int round, string opponent)
		{
			if (!IsLoaded)
			{
				return;
			}
			try
			{
				RaiseSimple("dvergr_tournament_match", subject, new Dictionary<string, object>
				{
					{ "round", round },
					{
						"opponent",
						opponent ?? string.Empty
					}
				});
			}
			catch (Exception arg)
			{
				Plugin.Log.LogWarning((object)$"ServerGuide integration (dvergr_tournament_match) failed: {arg}");
			}
		}

		public static void RaiseTournamentWon(string subject, string mode, int bracketSize)
		{
			if (!IsLoaded)
			{
				return;
			}
			try
			{
				RaiseSimple("dvergr_tournament_won", subject, new Dictionary<string, object>
				{
					{
						"mode",
						mode ?? string.Empty
					},
					{ "bracketSize", bracketSize }
				});
			}
			catch (Exception arg)
			{
				Plugin.Log.LogWarning((object)$"ServerGuide integration (dvergr_tournament_won) failed: {arg}");
			}
		}

		private static void RaiseRecruitedInternal(DvergrCaste caste)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			GuidanceDispatcher.Raise(new TriggerEvent
			{
				Type = "dvergr_recruited",
				Subject = caste.ToString()
			});
		}

		private static void RaiseLevelUpInternal(DvergrCaste caste, int level)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			GuidanceDispatcher.Raise(new TriggerEvent
			{
				Type = "dvergr_level_up",
				Subject = $"{caste}:{level}"
			});
		}

		private static void RaiseDuelWonInternal(DvergrCaste winner, DvergrCaste loser, string winnerName, string loserName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Expected O, but got Unknown
			GuidanceDispatcher.Raise(new TriggerEvent
			{
				Type = "dvergr_duel_won",
				Subject = winner.ToString(),
				Extra = new Dictionary<string, object>
				{
					{
						"loserCaste",
						loser.ToString()
					},
					{
						"companionName",
						winnerName ?? string.Empty
					},
					{
						"opponent",
						loserName ?? string.Empty
					}
				}
			});
		}

		private static void RaiseRankChangedInternal(int caste, int rank, int rating, string companionName, string ownerName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Expected O, but got Unknown
			TriggerEvent val = new TriggerEvent
			{
				Type = "dvergr_rank_changed"
			};
			DvergrCaste dvergrCaste = (DvergrCaste)caste;
			val.Subject = dvergrCaste.ToString();
			val.Extra = new Dictionary<string, object>
			{
				{ "rank", rank },
				{ "rating", rating },
				{
					"companionName",
					companionName ?? string.Empty
				},
				{
					"ownerName",
					ownerName ?? string.Empty
				}
			};
			GuidanceDispatcher.Raise(val);
		}

		private static void RaisePartyDuelWonInternal(string winnerOwnerName, int winSize, string loserOwnerName, int mvpCaste, string partyName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Expected O, but got Unknown
			TriggerEvent val = new TriggerEvent
			{
				Type = "dvergr_party_duel_won",
				Subject = (winnerOwnerName ?? string.Empty)
			};
			Dictionary<string, object> obj = new Dictionary<string, object>
			{
				{ "winSize", winSize },
				{
					"ownerName",
					winnerOwnerName ?? string.Empty
				},
				{
					"opponentOwner",
					loserOwnerName ?? string.Empty
				}
			};
			DvergrCaste dvergrCaste = (DvergrCaste)mvpCaste;
			obj.Add("mvpCaste", dvergrCaste.ToString());
			obj.Add("partyName", string.IsNullOrEmpty(partyName) ? (winnerOwnerName ?? string.Empty) : partyName);
			val.Extra = obj;
			GuidanceDispatcher.Raise(val);
		}

		private static void RaiseSimple(string type, string subject, Dictionary<string, object> extra)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			GuidanceDispatcher.Raise(new TriggerEvent
			{
				Type = type,
				Subject = (subject ?? string.Empty),
				Extra = extra
			});
		}

		private static void RaisePartyRankChangedInternal(string ownerName, int rank, int rating, string partyName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			GuidanceDispatcher.Raise(new TriggerEvent
			{
				Type = "dvergr_party_rank_changed",
				Subject = (ownerName ?? string.Empty),
				Extra = new Dictionary<string, object>
				{
					{ "rank", rank },
					{ "rating", rating },
					{
						"ownerName",
						ownerName ?? string.Empty
					},
					{
						"partyName",
						string.IsNullOrEmpty(partyName) ? (ownerName ?? string.Empty) : partyName
					}
				}
			});
		}
	}
}
namespace LostScrollsII.Economy
{
	public static class ValcoinBridge
	{
		private const string DonationsGuid = "com.taeguk.valheimdonations";

		private const string WalletTypeName = "ValcoinWallet";

		public const string SkuTournamentEntry = "ls_tourney_entry";

		public const string SkuDuelStake = "ls_duel_stake";

		public const string SkuRefund = "ls_wager_refund";

		public const string SkuDuelPurse = "ls_duel_purse";

		private static bool _probed;

		private static Type _wallet;

		private static MethodInfo _charge;

		private static MethodInfo _credit;

		private static PropertyInfo _ready;

		private static PropertyInfo _reason;

		public static bool Available
		{
			get
			{
				Probe();
				if (_wallet == null || _charge == null || _credit == null)
				{
					return false;
				}
				try
				{
					return _ready == null || (bool)_ready.GetValue(null);
				}
				catch
				{
					return false;
				}
			}
		}

		public static string UnavailableReason
		{
			get
			{
				Probe();
				if (_wallet == null || _charge == null || _credit == null)
				{
					return "Valcoin wagers need the Valheim Donations mod on this server.";
				}
				try
				{
					if (_ready != null && !(bool)_ready.GetValue(null))
					{
						return (_reason?.GetValue(null) as string) ?? "Valcoin wagers are not available on this server right now.";
					}
				}
				catch
				{
					return "Valcoin wagers are not available on this server right now.";
				}
				return null;
			}
		}

		public static void Charge(string playerName, string sku, int coins, string reason, Action<bool, string> done)
		{
			if (!Available)
			{
				done?.Invoke(arg1: false, UnavailableReason);
			}
			else
			{
				Invoke(_charge, playerName, sku, coins, reason, done);
			}
		}

		public static void Credit(string playerName, string sku, int coins, string reason, Action<bool, string> done)
		{
			if (!Available)
			{
				done?.Invoke(arg1: false, UnavailableReason);
			}
			else
			{
				Invoke(_credit, playerName, sku, coins, reason, done);
			}
		}

		private static void Invoke(MethodInfo m, string playerName, string sku, int coins, string reason, Action<bool, string> done)
		{
			try
			{
				m.Invoke(null, new object[5] { playerName, sku, coins, reason, done });
			}
			catch (Exception ex)
			{
				Exception ex2 = ex.InnerException ?? ex;
				Plugin.Log.LogWarning((object)$"[wager] Valcoin call failed ({sku}, {coins} for {playerName}): {ex2.Message}");
				done?.Invoke(arg1: false, "The Valcoin ledger could not be reached.");
			}
		}

		private static void Probe()
		{
			if (_probed)
			{
				return;
			}
			_probed = true;
			try
			{
				if (!Chainloader.PluginInfos.ContainsKey("com.taeguk.valheimdonations"))
				{
					foreach (KeyValuePair<string, PluginInfo> pluginInfo in Chainloader.PluginInfos)
					{
						PluginInfo value = pluginInfo.Value;
						object obj;
						if (value == null)
						{
							obj = null;
						}
						else
						{
							BepInPlugin metadata = value.Metadata;
							obj = ((metadata != null) ? metadata.Name : null);
						}
						if (obj == null)
						{
							obj = string.Empty;
						}
						if (((string)obj).IndexOf("donation", StringComparison.OrdinalIgnoreCase) >= 0)
						{
							Bind(((object)pluginInfo.Value.Instance)?.GetType().Assembly);
							break;
						}
					}
				}
				else
				{
					PluginInfo obj2 = Chainloader.PluginInfos["com.taeguk.valheimdonations"];
					Bind((obj2 == null) ? null : ((object)obj2.Instance)?.GetType().Assembly);
				}
				Plugin.Log.LogInfo((object)((_wallet != null) ? "[wager] Valcoin wallet API found — Valcoin wagers are available." : "[wager] No Valcoin wallet API found — Valcoin wagers will be refused (Coins still work)."));
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[wager] Valcoin bridge probe failed: " + ex.Message));
			}
		}

		private static void Bind(Assembly asm)
		{
			if (asm == null)
			{
				return;
			}
			_wallet = asm.GetType("ValcoinWallet", throwOnError: false);
			if (!(_wallet == null))
			{
				Type[] types = new Type[5]
				{
					typeof(string),
					typeof(string),
					typeof(int),
					typeof(string),
					typeof(Action<bool, string>)
				};
				_charge = _wallet.GetMethod("Charge", BindingFlags.Static | BindingFlags.Public, null, types, null);
				_credit = _wallet.GetMethod("Credit", BindingFlags.Static | BindingFlags.Public, null, types, null);
				_ready = _wallet.GetProperty("Ready", BindingFlags.Static | BindingFlags.Public);
				_reason = _wallet.GetProperty("UnavailableReason", BindingFlags.Static | BindingFlags.Public);
				if (_charge == null || _credit == null)
				{
					Plugin.Log.LogWarning((object)"[wager] Found ValcoinWallet but not its Charge/Credit(string,string,int,string,Action<bool,string>) methods — the donations plugin is probably older than this build. Valcoin wagers stay off.");
					_wallet = null;
				}
			}
		}
	}
	public enum WagerCurrency
	{
		None,
		Coins,
		Valcoin
	}
	public static class Wager
	{
		public const string CoinPrefab = "Coins";

		private static string _coinSharedName;

		public static string Key(WagerCurrency c)
		{
			if (c != WagerCurrency.Valcoin)
			{
				return "coins";
			}
			return "valcoin";
		}

		public static WagerCurrency Parse(string s)
		{
			if (string.IsNullOrEmpty(s))
			{
				return WagerCurrency.None;
			}
			switch (s.ToLowerInvariant())
			{
			case "valcoin":
			case "valcoins":
				return WagerCurrency.Valcoin;
			case "coins":
			case "coin":
				return WagerCurrency.Coins;
			default:
				return WagerCurrency.None;
			}
		}

		public static string Display(WagerCurrency c)
		{
			if (c != WagerCurrency.Valcoin)
			{
				return "Coins";
			}
			return "Valcoins";
		}

		public static int TournamentFee(WagerCurrency c)
		{
			if (c != WagerCurrency.Valcoin)
			{
				return Mathf.Max(0, Plugin.TournamentCoinFee.Value);
			}
			return Mathf.Max(0, Plugin.TournamentValcoinFee.Value);
		}

		public static int TournamentPrize(WagerCurrency c)
		{
			if (c != WagerCurrency.Valcoin)
			{
				return Mathf.Max(0, Plugin.TournamentCoinPrize.Value);
			}
			return Mathf.Max(0, Plugin.TournamentValcoinPrize.Value);
		}

		public static int DuelStake(WagerCurrency c)
		{
			if (c != WagerCurrency.Valcoin)
			{
				return Mathf.Max(0, Plugin.DuelCoinStake.Value);
			}
			return Mathf.Max(0, Plugin.DuelValcoinStake.Value);
		}

		public static string CoinSharedName()
		{
			if (!string.IsNullOrEmpty(_coinSharedName))
			{
				return _coinSharedName;
			}
			GameObject val = (((Object)(object)ObjectDB.instance != (Object)null) ? ObjectDB.instance.GetItemPrefab("Coins") : null);
			SharedData val2 = ((!((Object)(object)val != (Object)null)) ? null : val.GetComponent<ItemDrop>()?.m_itemData?.m_shared);
			if (val2 != null)
			{
				_coinSharedName = val2.m_name;
			}
			return _coinSharedName;
		}

		public static int CoinsHeld(Player player)
		{
			string text = CoinSharedName();
			if ((Object)(object)player == (Object)null || string.IsNullOrEmpty(text))
			{
				return 0;
			}
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (inventory != null)
			{
				return inventory.CountItems(text, -1, true);
			}
			return 0;
		}

		public static bool TryTakeCoins(Player player, int amount)
		{
			if ((Object)(object)player == (Object)null || amount <= 0)
			{
				return false;
			}
			string text = CoinSharedName();
			if (string.IsNullOrEmpty(text))
			{
				return false;
			}
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (inventory == null || inventory.CountItems(text, -1, true) < amount)
			{
				return false;
			}
			inventory.RemoveItem(text, amount, -1, true);
			return true;
		}

		public static void GiveCoins(Player player, int amount)
		{
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null || amount <= 0)
			{
				return;
			}
			GameObject val = (((Object)(object)ObjectDB.instance != (Object)null) ? ObjectDB.instance.GetItemPrefab("Coins") : null);
			ItemDrop val2 = (((Object)(object)val != (Object)null) ? val.GetComponent<ItemDrop>() : null);
			if ((Object)(object)val2 == (Object)null)
			{
				Plugin.Log.LogWarning((object)string.Format("[wager] '{0}' prefab missing — cannot pay {1} coins.", "Coins", amount));
				return;
			}
			int num = Mathf.Max(1, val2.m_itemData.m_shared.m_maxStackSize);
			Inventory inventory = ((Humanoid)player).GetInventory();
			int num2 = amount;
			while (num2 > 0)
			{
				int num3 = Mathf.Min(num2, num);
				num2 -= num3;
				ItemData val3 = val2.m_itemData.Clone();
				val3.m_dropPrefab = val;
				val3.m_stack = num3;
				val3.m_quality = 1;
				val3.m_worldLevel = (byte)Game.m_worldLevel;
				if (inventory == null || !inventory.AddItem(val3))
				{
					ItemDrop.DropItem(val3, num3, ((Component)player).transform.position + Vector3.up, ((Component)player).transform.rotation);
				}
			}
		}
	}
	public static class WagerService
	{
		public static bool IsAvailable(WagerCurrency currency, out string reason)
		{
			reason = null;
			if (!Plugin.WagersEnabled.Value)
			{
				reason = "Wagered events are disabled on this server.";
				return false;
			}
			switch (currency)
			{
			case WagerCurrency.Valcoin:
				reason = ValcoinBridge.UnavailableReason;
				return reason == null;
			case WagerCurrency.Coins:
				return true;
			default:
				reason = "Unknown currency.";
				return false;
			}
		}

		public static string ClientHint(WagerCurrency currency)
		{
			if (!Plugin.WagersEnabled.Value)
			{
				return "Wagered events are disabled.";
			}
			if (!((Object)(object)ZNet.instance != (Object)null) || !ZNet.instance.IsServer())
			{
				return null;
			}
			IsAvailable(currency, out var reason);
			return reason;
		}

		public static void Charge(WagerCurrency currency, string playerName, int amount, string sku, string reason, int clientReportedPaid, Action<bool, string> done)
		{
			if (amount <= 0)
			{
				done?.Invoke(arg1: true, null);
				return;
			}
			if (!IsAvailable(currency, out var reason2))
			{
				done?.Invoke(arg1: false, reason2);
				return;
			}
			if (currency == WagerCurrency.Coins)
			{
				if (clientReportedPaid < amount)
				{
					done?.Invoke(arg1: false, $"You need {amount} Coins to enter.");
					return;
				}
				Plugin.Log.LogInfo((object)$"[wager] {playerName} staked {amount} Coins ({sku}).");
				done?.Invoke(arg1: true, null);
				return;
			}
			ValcoinBridge.Charge(playerName, sku, amount, reason, delegate(bool ok, string msg)
			{
				if (ok)
				{
					Plugin.Log.LogInfo((object)$"[wager] {playerName} staked {amount} Valcoins ({sku}).");
				}
				else
				{
					Plugin.Log.LogInfo((object)$"[wager] {playerName} could not stake {amount} Valcoins ({sku}): {msg}");
				}
				done?.Invoke(ok, msg);
			});
		}

		public static void Pay(WagerCurrency currency, long ownerId, string playerName, int amount, string sku, string reason)
		{
			if (amount <= 0)
			{
				return;
			}
			switch (currency)
			{
			case WagerCurrency.None:
				Plugin.Log.LogWarning((object)$"[wager] ignoring a {amount} payout to {playerName} with no currency ({reason}).");
				return;
			case WagerCurrency.Coins:
				LeaderboardSync.SendWagerPayout(ownerId, amount, reason);
				Plugin.Log.LogInfo((object)$"[wager] paid {amount} Coins to {playerName} ({reason}).");
				return;
			}
			if (!ValcoinBridge.Available)
			{
				Plugin.Log.LogWarning((object)($"[wager] OWED {amount} Valcoins to {playerName} ({reason}) but the " + "Valcoin wallet is unavailable — settle this by hand."));
				return;
			}
			ValcoinBridge.Credit(playerName, sku, amount, reason, delegate(bool ok, string msg)
			{
				if (ok)
				{
					Plugin.Log.LogInfo((object)$"[wager] paid {amount} Valcoins to {playerName} ({reason}).");
				}
				else
				{
					Plugin.Log.LogWarning((object)($"[wager] FAILED to pay {amount} Valcoins to {playerName} ({reason}): {msg} " + "— settle this by hand."));
				}
			});
		}

		public static void Refund(WagerCurrency currency, long ownerId, string playerName, int amount, string what)
		{
			Pay(currency, ownerId, playerName, amount, "ls_wager_refund", "refund: " + what);
		}

		public static void RollBackOwnCharge(WagerCurrency currency, long ownerId, string playerName, int amount, string what)
		{
			if (currency == WagerCurrency.Valcoin)
			{
				Refund(currency, ownerId, playerName, amount, what);
			}
		}
	}
}
namespace LostScrollsII.Companions
{
	public class ChoreAI : MonoBehaviour
	{
		public enum ChoreKind
		{
			None,
			Smelter,
			Farm,
			FeedAnimals,
			Fermenter,
			Cooking,
			Haul
		}

		public const string ZdoKeyChoreKind = "DE_ChoreKind";

		public const string ZdoKeyChorePos = "DE_ChorePos";

		private const float RestoreResolveRadius = 3f;

		private static readonly Dictionary<GameObject, ChoreAI> s_claims = new Dictionary<GameObject, ChoreAI>();

		private const float ArrivalRange = 4.5f;

		private const float ContainerSearchRadius = 8f;

		private const float WorkRadius = 10f;

		private const float FeedInterval = 5f;

		private const float NotifyInterval = 60f;

		private const float NotifyRange = 20f;

		private Humanoid _humanoid;

		private MonsterAI _ai;

		private DvergrCompanion _companion;

		private ZNetView _znv;

		private float _lastSayTime = -999f;

		private bool _pendingRestore;

		private ChoreKind _restoreKind;

		private Vector3 _restorePos;

		private float _restoreTimer;

		private Container _openChest;

		private float _closeChestTime;

		private ChoreKind _kind;

		private Smelter _station;

		private Fermenter _fermenter;

		private CookingStation _cooker;

		private Container _haulChest;

		private GameObject _anchorObject;

		private GameObject _claimedAnchor;

		private float _feedTimer;

		public string WorkerName
		{
			get
			{
				if (!((Object)(object)_companion != (Object)null))
				{
					if (!((Object)(object)_humanoid != (Object)null))
					{
						return "An ally";
					}
					return ((Character)_humanoid).GetHoverName();
				}
				return _companion.DisplayName;
			}
		}

		public bool IsAssigned => _kind != ChoreKind.None;

		public static ChoreAI ClaimantOf(GameObject anchor)
		{
			if ((Object)(object)anchor == (Object)null)
			{
				return null;
			}
			if (s_claims.TryGetValue(anchor, out var value))
			{
				if ((Object)(object)value != (Object)null && value.IsAssigned)
				{
					return value;
				}
				s_claims.Remove(anchor);
			}
			return null;
		}

		public static ChoreAI FeederCovering(Vector3 pos)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			foreach (DvergrCompanion item in DvergrCompanion.All)
			{
				if (!((Object)(object)item == (Object)null))
				{
					ChoreAI component = ((Component)item).GetComponent<ChoreAI>();
					if ((Object)(object)component != (Object)null && component.IsAssigned && component._kind == ChoreKind.FeedAnimals && Vector3.Distance(component.CurrentCenter(), pos) <= 10f)
					{
						return component;
					}
				}
			}
			return null;
		}

		private void Awake()
		{
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			_humanoid = ((Component)this).GetComponent<Humanoid>();
			_ai = ((Component)this).GetComponent<MonsterAI>();
			_companion = ((Component)this).GetComponent<DvergrCompanion>();
			_znv = ((Component)this).GetComponent<ZNetView>();
			if ((Object)(object)_znv != (Object)null && _znv.IsValid())
			{
				int num = _znv.GetZDO().GetInt("DE_ChoreKind", 0);
				if (num != 0)
				{
					_restoreKind = (ChoreKind)num;
					_restorePos = _znv.GetZDO().GetVec3("DE_ChorePos", ((Component)this).transform.position);
					_pendingRestore = true;
				}
			}
		}

		public static bool HasPersistedChore(ZNetView znv)
		{
			if ((Object)(object)znv != (Object)null && znv.IsValid())
			{
				return znv.GetZDO().GetInt("DE_ChoreKind", 0) != 0;
			}
			return false;
		}

		public void AssignToSmelter(Smelter station)
		{
			_kind = ChoreKind.Smelter;
			_station = station;
			BeginChore(((Object)(object)station != (Object)null) ? ((Component)station).gameObject : null);
		}

		public void AssignToFarm(GameObject cropAnchor)
		{
			_kind = ChoreKind.Farm;
			BeginChore(cropAnchor);
		}

		public void AssignToFeedAnimals(GameObject animalAnchor)
		{
			_kind = ChoreKind.FeedAnimals;
			BeginChore(animalAnchor);
		}

		public void AssignToFermenter(Fermenter fermenter)
		{
			_kind = ChoreKind.Fermenter;
			_fermenter = fermenter;
			BeginChore(((Object)(object)fermenter != (Object)null) ? ((Component)fermenter).gameObject : null);
		}

		public void AssignToCooking(CookingStation cooker)
		{
			_kind = ChoreKind.Cooking;
			_cooker = cooker;
			BeginChore(((Object)(object)cooker != (Object)null) ? ((Component)cooker).gameObject : null);
		}

		public void AssignToHaul(Container chest)
		{
			_kind = ChoreKind.Haul;
			_haulChest = chest;
			BeginChore(((Object)(object)chest != (Object)null) ? ((Component)chest).gameObject : null);
		}

		private void BeginChore(GameObject anchor)
		{
			_anchorObject = anchor;
			_feedTimer = 0f;
			Claim(anchor);
			PersistChore(anchor);
			if ((Object)(object)_ai != (Object)null && (Object)(object)anchor != (Object)null)
			{
				_ai.SetFollowTarget(anchor);
			}
			if ((Object)(object)_companion != (Object)null)
			{
				_companion.ChoreActive = true;
				_companion.SetPassive(passive: true);
			}
		}

		private void PersistChore(GameObject anchor)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_znv == (Object)null) && _znv.IsValid())
			{
				ZDO zDO = _znv.GetZDO();
				zDO.Set("DE_ChoreKind", (int)_kind);
				zDO.Set("DE_ChorePos", ((Object)(object)anchor != (Object)null) ? anchor.transform.position : ((Component)this).transform.position);
			}
		}

		private void ClearPersistedChore()
		{
			if (!((Object)(object)_znv == (Object)null) && _znv.IsValid())
			{
				_znv.GetZDO().Set("DE_ChoreKind", 0);
			}
		}

		private void TryRestore()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ZNetScene.instance == (Object)null)
			{
				return;
			}
			GameObject val = FindRestoreTarget(_restoreKind, _restorePos);
			if ((Object)(object)val != (Object)null)
			{
				_pendingRestore = false;
				ResumeChore(_restoreKind, val);
				return;
			}
			_restoreTimer += Time.deltaTime;
			if (_restoreTimer > 60f)
			{
				_pendingRestore = false;
				ClearPersistedChore();
			}
		}

		private GameObject FindRestoreTarget(ChoreKind kind, Vector3 pos)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			float num = ((kind == ChoreKind.Farm || kind == ChoreKind.FeedAnimals) ? 10f : 3f);
			Collider[] array = Physics.OverlapSphere(pos, num);
			foreach (Collider val in array)
			{
				switch (kind)
				{
				case ChoreKind.Smelter:
				{
					Smelter componentInParent2 = ((Component)val).GetComponentInParent<Smelter>();
					if ((Object)(object)componentInParent2 != (Object)null)
					{
						return ((Component)componentInParent2).gameObject;
					}
					break;
				}
				case ChoreKind.Fermenter:
				{
					Fermenter componentInParent4 = ((Component)val).GetComponentInParent<Fermenter>();
					if ((Object)(object)componentInParent4 != (Object)null)
					{
						return ((Component)componentInParent4).gameObject;
					}
					break;
				}
				case ChoreKind.Cooking:
				{
					CookingStation componentInParent8 = ((Component)val).GetComponentInParent<CookingStation>();
					if ((Object)(object)componentInParent8 != (Object)null)
					{
						return ((Component)componentInParent8).gameObject;
					}
					break;
				}
				case ChoreKind.Haul:
				{
					Container componentInParent3 = ((Component)val).GetComponentInParent<Container>();
					if ((Object)(object)componentInParent3 != (Object)null)
					{
						return ((Component)componentInParent3).gameObject;
					}
					break;
				}
				case ChoreKind.Farm:
				{
					ItemStand componentInParent5 = ((Component)val).GetComponentInParent<ItemStand>();
					if ((Object)(object)componentInParent5 != (Object)null && componentInParent5.HaveAttachment() && componentInParent5.GetAttachedItem() == "Cultivator")
					{
						return ((Component)componentInParent5).gameObject;
					}
					Pickable componentInParent6 = ((Component)val).GetComponentInParent<Pickable>();
					if ((Object)(object)componentInParent6 != (Object)null)
					{
						return ((Component)componentInParent6).gameObject;
					}
					Plant componentInParent7 = ((Component)val).GetComponentInParent<Plant>();
					if ((Object)(object)componentInParent7 != (Object)null)
					{
						return ((Component)componentInParent7).gameObject;
					}
					break;
				}
				case ChoreKind.FeedAnimals:
				{
					Character componentInParent = ((Component)val).GetComponentInParent<Character>();
					if ((Object)(object)componentInParent != (Object)null && componentInParent.IsTamed() && (Object)(object)((Component)componentInParent).GetComponent<DvergrCompanion>() == (Object)null)
					{
						return ((Component)componentInParent).gameObject;
					}
					break;
				}
				}
			}
			return null;
		}

		private void ResumeChore(ChoreKind kind, GameObject go)
		{
			switch (kind)
			{
			case ChoreKind.Smelter:
			{
				Smelter componentInParent4 = go.GetComponentInParent<Smelter>();
				if ((Object)(object)componentInParent4 != (Object)null)
				{
					AssignToSmelter(componentInParent4);
				}
				break;
			}
			case ChoreKind.Fermenter:
			{
				Fermenter componentInParent2 = go.GetComponentInParent<Fermenter>();
				if ((Object)(object)componentInParent2 != (Object)null)
				{
					AssignToFermenter(componentInParent2);
				}
				break;
			}
			case ChoreKind.Cooking:
			{
				CookingStation componentInParent3 = go.GetComponentInParent<CookingStation>();
				if ((Object)(object)componentInParent3 != (Object)null)
				{
					AssignToCooking(componentInParent3);
				}
				break;
			}
			case ChoreKind.Haul:
			{
				Container componentInParent = go.GetComponentInParent<Container>();
				if ((Object)(object)componentInParent != (Object)null)
				{
					AssignToHaul(componentInParent);
				}
				break;
			}
			case ChoreKind.Farm:
				AssignToFarm(go);
				break;
			case ChoreKind.FeedAnimals:
				AssignToFeedAnimals(go);
				break;
			}
			if (!IsAssigned)
			{
				ClearPersistedChore();
			}
		}

		private void Claim(GameObject anchor)
		{
			ReleaseClaim();
			if (!((Object)(object)anchor == (Object)null))
			{
				s_claims[anchor] = this;
				_claimedAnchor = anchor;
			}
		}

		private void ReleaseClaim()
		{
			if (!((Object)(object)_claimedAnchor == (Object)null))
			{
				if (s_claims.TryGetValue(_claimedAnchor, out var value) && (Object)(object)value == (Object)(object)this)
				{
					s_claims.Remove(_claimedAnchor);
				}
				_claimedAnchor = null;
			}
		}

		private void OnDisable()
		{
			ReleaseClaim();
		}

		public void Unassign()
		{
			_kind = ChoreKind.None;
			_station = null;
			_fermenter = null;
			_cooker = null;
			_haulChest = null;
			_anchorObject = null;
			_pendingRestore = false;
			ReleaseClaim();
			ClearPersistedChore();
			ClearSpeech();
			CloseChest();
			if ((Object)(object)_companion != (Object)null)
			{
				_companion.ChoreActive = false;
				DvergrCompanion companion = _companion;
				Player obj = _companion.OwnerPlayer();
				companion.SetStance(CompanionStance.Follow, (obj != null) ? ((Component)obj).gameObject : null);
			}
			else if ((Object)(object)_ai != (Object)null)
			{
				_ai.SetFollowTarget((GameObject)null);
			}
		}

		private void FaceToward(Vector3 pos)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = pos - ((Component)this).transform.position;
			val.y = 0f;
			if (((Vector3)(ref val)).sqrMagnitude > 0.01f && (Object)(object)_humanoid != (Object)null)
			{
				((Character)_humanoid).SetLookDir(((Vector3)(ref val)).normalized, 0f);
			}
		}

		private void OpenChest(Container c)
		{
			if (!((Object)(object)c == (Object)null))
			{
				if ((Object)(object)_openChest != (Object)(object)c)
				{
					CloseChest();
					c.SetInUse(true);
					_openChest = c;
				}
				_closeChestTime = Time.time + 1.5f;
			}
		}

		private void CloseChest()
		{
			if ((Object)(object)_openChest != (Object)null)
			{
				_openChest.SetInUse(false);
				_openChest = null;
			}
		}

		private Vector3 CurrentCenter()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			if (_kind == ChoreKind.Smelter && (Object)(object)_station != (Object)null)
			{
				return ((Component)_station).transform.position;
			}
			if (_kind == ChoreKind.Fermenter && (Object)(object)_fermenter != (Object)null)
			{
				return ((Component)_fermenter).transform.position;
			}
			if (_kind == ChoreKind.Cooking && (Object)(object)_cooker != (Object)null)
			{
				return ((Component)_cooker).transform.position;
			}
			if (_kind == ChoreKind.Haul && (Object)(object)_haulChest != (Object)null)
			{
				return ((Component)_haulChest).transform.position;
			}
			if ((Object)(object)_anchorObject != (Object)null)
			{
				return _anchorObject.transform.position;
			}
			return ((Component)this).transform.position;
		}

		private void Update()
		{
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_openChest != (Object)null && Time.time > _closeChestTime)
			{
				CloseChest();
			}
			if (_pendingRestore)
			{
				TryRestore();
			}
			else
			{
				if (_kind == ChoreKind.None || (Object)(object)_humanoid == (Object)null || ((Object)(object)_znv != (Object)null && _znv.IsValid() && !_znv.IsOwner()))
				{
					return;
				}
				if ((Object)(object)_anchorObject == (Object)null)
				{
					Unassign();
					return;
				}
				_feedTimer += Time.deltaTime;
				if (_feedTimer < 5f)
				{
					return;
				}
				_feedTimer = 0f;
				if (Vector3.Distance(((Component)this).transform.position, CurrentCenter()) > 4.5f)
				{
					Say((_kind == ChoreKind.Farm) ? "I can't reach the field!" : ((_kind == ChoreKind.FeedAnimals) ? "I can't reach the pen!" : ((_kind == ChoreKind.Haul) ? "I can't reach the chest!" : "I can't reach my station!")));
					return;
				}
				switch (_kind)
				{
				case ChoreKind.Smelter:
					ServiceStation();
					break;
				case ChoreKind.Farm:
					ServiceFarm();
					break;
				case ChoreKind.FeedAnimals:
					ServiceAnimals();
					break;
				case ChoreKind.Fermenter:
					ServiceFermenter();
					break;
				case ChoreKind.Cooking:
					ServiceCooking();
					break;
				case ChoreKind.Haul:
					ServiceHaul();
					break;
				}
			}
		}

		private void ServiceStation()
		{
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			bool flag = _station.GetQueueSize() < _station.m_maxOre;
			bool flag2 = (Object)(object)_station.m_fuelItem != (Object)null && _station.GetFuel() < (float)_station.m_maxFuel;
			if (!flag && !flag2)
			{
				ClearSpeech();
				return;
			}
			string text = (((Object)(object)_station.m_fuelItem != (Object)null) ? ((Object)_station.m_fuelItem).name : null);
			bool fuelMissing = flag2;
			bool oreMissing = flag;
			Inventory inventory = _humanoid.GetInventory();
			Collider[] array = Physics.OverlapSphere(((Component)_station).transform.position, 8f);
			bool flag3 = false;
			Collider[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				Container componentInParent = ((Component)array2[i]).GetComponentInParent<Container>();
				Inventory val = (((Object)(object)componentInParent != (Object)null) ? componentInParent.GetInventory() : null);
				if (val == null)
				{
					continue;
				}
				flag3 = true;
				foreach (ItemData item in new List<ItemData>(val.GetAllItems()))
				{
					string text2 = (((Object)(object)item.m_dropPrefab != (Object)null) ? ((Object)item.m_dropPrefab).name : null);
					if (text2 == null)
					{
						continue;
					}
					if (flag2 && text2 == text)
					{
						if (val.RemoveItem(item, 1))
						{
							inventory.AddItem(item.Clone());
							OpenChest(componentInParent);
							FaceToward(((Component)_station).transform.position);
							_station.SetFuel(_station.GetFuel() + 1f);
							PlayEffects(_station.m_fuelAddedEffects, ((Component)_station).transform);
							flag2 = false;
							fuelMissing = false;
						}
					}
					else if (flag && _station.GetItemConversion(text2) != null && val.RemoveItem(item, 1))
					{
						inventory.AddItem(item.Clone());
						OpenChest(componentInParent);
						FaceToward(((Component)_station).transform.position);
						_station.QueueOre(text2);
						PlayEffects(_station.m_oreAddedEffects, ((Component)_station).transform);
						flag = false;
						oreMissing = false;
					}
				}
				if (!flag && !flag2)
				{
					break;
				}
			}
			if (!flag3)
			{
				Say("I have no chest to draw from!");
			}
			else
			{
				ReportMissing(oreMissing, fuelMissing);
			}
		}

		private string InputNames()
		{
			HashSet<string> hashSet = new HashSet<string>();
			if ((Object)(object)_station != (Object)null && _station.m_conversion != null)
			{
				foreach (ItemConversion item in _station.m_conversion)
				{
					if (item != null && (Object)(object)item.m_from != (Object)null && item.m_from.m_itemData != null && item.m_from.m_itemData.m_shared != null)
					{
						hashSet.Add(Localization.instance.Localize(item.m_from.m_itemData.m_shared.m_name));
					}
				}
			}
			if (hashSet.Count <= 0)
			{
				return "materials";
			}
			return string.Join(" or ", hashSet);
		}

		private string FuelName()
		{
			if ((Object)(object)_station != (Object)null && (Object)(object)_station.m_fuelItem != (Object)null && _station.m_fuelItem.m_itemData != null && _station.m_fuelItem.m_itemData.m_shared != null)
			{
				return Localization.instance.Localize(_station.m_fuelItem.m_itemData.m_shared.m_name);
			}
			return "fuel";
		}

		private void ServiceFarm()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = CurrentCenter();
			Inventory val2 = FirstContainerInventory(val);
			Collider[] array = Physics.OverlapSphere(val, 10f);
			for (int i = 0; i < array.Length; i++)
			{
				Pickable componentInParent = ((Component)array[i]).GetComponentInParent<Pickable>();
				if ((Object)(object)componentInParent == (Object)null || !componentInParent.CanBePicked())
				{
					continue;
				}
				if (val2 == null)
				{
					Say("I have no chest for the harvest.");
					return;
				}
				GameObject itemPrefab = componentInParent.m_itemPrefab;
				int num = Mathf.Max(1, componentInParent.m_amount);
				if (!((Object)(object)itemPrefab == (Object)null))
				{
					if (!val2.CanAddItem(itemPrefab, num))
					{
						Say("The harvest chest is full!");
						return;
					}
					val2.AddItem(itemPrefab, num);
					componentInParent.SetPicked(true);
					FaceToward(((Component)componentInParent).transform.position);
					PlayEffects(componentInParent.m_pickEffector, null, ((Component)componentInParent).transform.position);
					ClearSpeech();
					return;
				}
			}
			if (val2 == null)
			{
				Say("I have no chest for the seeds.");
				return;
			}
			ItemData val3 = null;
			GameObject val4 = null;
			bool flag = false;
			foreach (ItemData allItem in val2.GetAllItems())
			{
				if (PlantingCatalog.TryGetSapling(((Object)(object)allItem.m_dropPrefab != (Object)null) ? ((Object)allItem.m_dropPrefab).name : null, out var sapling))
				{
					if (CanGrowInBiome(sapling.GetComponent<Plant>(), val))
					{
						val3 = allItem;
						val4 = sapling;
						break;
					}
					flag = true;
				}
			}
			Vector3 spot;
			if ((Object)(object)val4 == (Object)null)
			{
				Say(flag ? "These seeds won't grow in this land." : "No crops are ready, and no seeds to plant.");
			}
			else if (!TryFindPlantSpot(val, val4, out spot))
			{
				Say("There's no room left to plant.");
			}
			else if (val2.RemoveItem(val3, 1))
			{
				Object.Instantiate<GameObject>(val4, spot, Quaternion.Euler(0f, Random.Range(0f, 360f), 0f));
				Piece component = val4.GetComponent<Piece>();
				if ((Object)(object)component != (Object)null)
				{
					PlayEffects(component.m_placeEffect, null, spot);
				}
				FaceToward(spot);
				Plugin.Log.LogInfo((object)$"[farm] planted '{((Object)val4).name}' at {spot} (biome {CurrentBiome(spot)}).");
				ClearSpeech();
			}
		}

		private bool TryFindPlantSpot(Vector3 center, GameObject sapling, out Vector3 spot)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			spot = center;
			Plant component = sapling.GetComponent<Plant>();
			float radius = (((Object)(object)component != (Object)null) ? Mathf.Max(component.m_growRadius, 0.5f) : 1f);
			ZoneSystem instance = ZoneSystem.instance;
			Vector3 val2 = default(Vector3);
			for (int i = 0; i < 24; i++)
			{
				Vector2 val = Random.insideUnitCircle * 8.5f;
				((Vector3)(ref val2))..ctor(center.x + val.x, center.y, center.z + val.y);
				if ((Object)(object)instance != (Object)null)
				{
					val2.y = instance.GetGroundHeight(val2);
				}
				Heightmap val3 = Heightmap.FindHeightmap(val2);
				if (!((Object)(object)val3 == (Object)null) && val3.IsCultivated(val2) && CanGrowInBiome(component, val2) && IsSpotClear(val2, radius))
				{
					spot = val2;
					return true;
				}
			}
			return false;
		}

		private static bool IsSpotClear(Vector3 p, float radius)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			Collider[] array = Physics.OverlapSphere(p, radius);
			foreach (Collider val in array)
			{
				if ((Object)(object)((Component)val).GetComponentInParent<Plant>() != (Object)null)
				{
					return false;
				}
				Pickable componentInParent = ((Component)val).GetComponentInParent<Pickable>();
				if ((Object)(object)componentInParent != (Object)null && !componentInParent.GetPicked())
				{
					return false;
				}
			}
			return true;
		}

		private static bool CanGrowInBiome(Plant plant, Vector3 pos)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Invalid comparison between Unknown and I4
			if ((Object)(object)plant == (Object)null)
			{
				return true;
			}
			if (WorldGenerator.instance == null)
			{
				return true;
			}
			Biome biome = WorldGenerator.instance.GetBiome(pos);
			return (plant.m_biome & biome) > 0;
		}

		private static Biome CurrentBiome(Vector3 pos)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (WorldGenerator.instance == null)
			{
				return (Biome)0;
			}
			return WorldGenerator.instance.GetBiome(pos);
		}

		private void ServiceAnimals()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = CurrentCenter();
			List<Character> list = new List<Character>();
			Collider[] array = Physics.OverlapSphere(val, 10f);
			for (int i = 0; i < array.Length; i++)
			{
				Character componentInParent = ((Component)array[i]).GetComponentInParent<Character>();
				if (!((Object)(object)componentInParent == (Object)null) && componentInParent.IsTamed() && !((Object)(object)((Component)componentInParent).GetComponent<DvergrCompanion>() != (Object)null))
				{
					Tameable component = ((Component)componentInParent).GetComponent<Tameable>();
					if ((Object)(object)component != (Object)null && component.IsHungry() && !list.Contains(componentInParent))
					{
						list.Add(componentInParent);
					}
				}
			}
			if (list.Count == 0)
			{
				Say("The animals aren't hungry.");
				return;
			}
			Inventory val2 = FirstContainerInventory(val);
			if (val2 == null)
			{
				Say("I have no food chest nearby.");
				return;
			}
			foreach (Character item in list)
			{
				MonsterAI component2 = ((Component)item).GetComponent<MonsterAI>();
				if (!((Object)(object)component2 == (Object)null) && component2.m_consumeItems != null && !ItemAlreadyDroppedNear(((Component)item).transform.position))
				{
					ItemData val3 = FindAcceptedFood(val2, component2.m_consumeItems);
					if (val3 == null)
					{
						Say("I have no food to give.");
						return;
					}
					if (val2.RemoveItem(val3, 1))
					{
						ItemData obj = val3.Clone();
						obj.m_stack = 1;
						ItemDrop.DropItem(obj, 1, ((Component)item).transform.position + Vector3.up * 0.3f, Quaternion.identity);
						ClearSpeech();
						return;
					}
				}
			}
			ClearSpeech();
		}

		private static ItemData FindAcceptedFood(Inventory chest, List<ItemDrop> consumeItems)
		{
			foreach (ItemData allItem in chest.GetAllItems())
			{
				string text = (((Object)(object)allItem.m_dropPrefab != (Object)null) ? ((Object)allItem.m_dropPrefab).name : null);
				if (text == null)
				{
					continue;
				}
				foreach (ItemDrop consumeItem in consumeItems)
				{
					if ((Object)(object)consumeItem != (Object)null && ((Object)consumeItem).name == text)
					{
						return allItem;
					}
				}
			}
			return null;
		}

		private static bool ItemAlreadyDroppedNear(Vector3 pos)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			Collider[] array = Physics.OverlapSphere(pos, 2f);
			for (int i = 0; i < array.Length; i++)
			{
				if ((Object)(object)((Component)array[i]).GetComponentInParent<ItemDrop>() != (Object)null)
				{
					return true;
				}
			}
			return false;
		}

		private void ServiceFermenter()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected I4, but got Unknown
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			Status status = _fermenter.GetStatus();
			switch (status - 1)
			{
			case 2:
				_fermenter.Interact(_humanoid, false, false);
				ClearSpeech();
				return;
			case 0:
				ClearSpeech();
				return;
			case 1:
				Say("The brew is exposed to the sky!");
				return;
			}
			Inventory val = FirstContainerInventory(CurrentCenter());
			if (val == null)
			{
				Say("I have no chest to brew from!");
				return;
			}
			foreach (ItemData item in new List<ItemData>(val.GetAllItems()))
			{
				string text = (((Object)(object)item.m_dropPrefab != (Object)null) ? ((Object)item.m_dropPrefab).name : null);
				if (text != null && _fermenter.IsItemAllowed(text) && val.RemoveItem(item, 1))
				{
					ItemData val2 = item.Clone();
					val2.m_stack = 1;
					_humanoid.GetInventory().AddItem(val2);
					if (_fermenter.AddItem(_humanoid, val2))
					{
						ClearSpeech();
						return;
					}
				}
			}
			Say("I have nothing to brew!");
		}

		private void ServiceCooking()
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			if (_cooker.HaveDoneItem())
			{
				_cooker.OnInteract(_humanoid);
				ClearSpeech();
				return;
			}
			if ((Object)(object)_cooker.m_fuelItem != (Object)null && _cooker.GetFuel() < (float)_cooker.m_maxFuel)
			{
				Inventory val = FirstContainerInventory(CurrentCenter());
				string name = ((Object)_cooker.m_fuelItem).name;
				if (val != null)
				{
					foreach (ItemData item in new List<ItemData>(val.GetAllItems()))
					{
						if (!((((Object)(object)item.m_dropPrefab != (Object)null) ? ((Object)item.m_dropPrefab).name : null) != name) && val.RemoveItem(item, 1))
						{
							_humanoid.GetInventory().AddItem(item.Clone());
							_cooker.SetFuel(_cooker.GetFuel() + 1f);
							ClearSpeech();
							return;
						}
					}
				}
			}
			if (_cooker.m_requireFire && !_cooker.IsFireLit())
			{
				Say("The cooking fire is out!");
				return;
			}
			if (_cooker.GetFreeSlot() < 0)
			{
				ClearSpeech();
				return;
			}
			Inventory val2 = FirstContainerInventory(CurrentCenter());
			if (val2 == null)
			{
				Say("I have no chest to cook from!");
				return;
			}
			foreach (ItemData item2 in new List<ItemData>(val2.GetAllItems()))
			{
				string text = (((Object)(object)item2.m_dropPrefab != (Object)null) ? ((Object)item2.m_dropPrefab).name : null);
				if (text != null && _cooker.GetItemConversion(text) != null && val2.RemoveItem(item2, 1))
				{
					ItemData val3 = item2.Clone();
					val3.m_stack = 1;
					_humanoid.GetInventory().AddItem(val3);
					if (_cooker.CookItem(_humanoid, val3))
					{
						ClearSpeech();
						return;
					}
				}
			}
			Say("I have nothing to cook!");
		}

		private void ServiceHaul()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			Inventory val = (((Object)(object)_haulChest != (Object)null) ? _haulChest.GetInventory() : null);
			if (val == null)
			{
				return;
			}
			Collider[] array = Physics.OverlapSphere(CurrentCenter(), 10f);
			for (int i = 0; i < array.Length; i++)
			{
				ItemDrop componentInParent = ((Component)array[i]).GetComponentInParent<ItemDrop>();
				if ((Object)(object)componentInParent == (Object)null || !componentInParent.CanPickup(false))
				{
					continue;
				}
				ZNetView component = ((Component)componentInParent).GetComponent<ZNetView>();
				if ((Object)(object)component == (Object)null || !component.IsValid())
				{
					continue;
				}
				ItemData itemData = componentInParent.m_itemData;
				if (itemData != null)
				{
					if (!val.CanAddItem(itemData, itemData.m_stack))
					{
						Say("The haul chest is full!");
						return;
					}
					val.AddItem(itemData.Clone());
					OpenChest(_haulChest);
					FaceToward(((Component)_haulChest).transform.position);
					component.ClaimOwnership();
					ZNetScene.instance.Destroy(((Component)componentInParent).gameObject);
					ClearSpeech();
					return;
				}
			}
			ClearSpeech();
		}

		private Inventory FirstContainerInventory(Vector3 center)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			Collider[] array = Physics.OverlapSphere(center, 8f);
			for (int i = 0; i < array.Length; i++)
			{
				Container componentInParent = ((Component)array[i]).GetComponentInParent<Container>();
				Inventory val = (((Object)(object)componentInParent != (Object)null) ? componentInParent.GetInventory() : null);
				if (val != null)
				{
					return val;
				}
			}
			return null;
		}

		private void PlayEffects(EffectList effects, Transform parent, Vector3? at = null)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (effects != null)
			{
				Vector3 val = (Vector3)(((??)at) ?? (((Object)(object)parent != (Object)null) ? parent.position : ((Component)this).transform.position));
				effects.Create(val, Quaternion.identity, parent, 1f, -1);
			}
		}

		private void ReportMissing(bool oreMissing, bool fuelMissing)
		{
			string text = ((oreMissing && fuelMissing) ? ("I need more " + InputNames() + " and " + FuelName() + "!") : (fuelMissing ? ("I need more " + FuelName() + "!") : (oreMissing ? ("I need more " + InputNames() + "!") : null)));
			if (text == null)
			{
				ClearSpeech();
			}
			else
			{
				Say(text);
			}
		}

		private void Say(string text)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Chat.instance == (Object)null) && !((Object)(object)_companion == (Object)null) && _companion.IsOwnerNear(20f) && !(Time.time - _lastSayTime < 60f))
			{
				_lastSayTime = Time.time;
				Chat.instance.SetNpcText(((Component)this).gameObject, Vector3.up * 2.2f, 20f, 8f, string.Empty, text, false);
			}
		}

		private void ClearSpeech()
		{
			if ((Object)(object)Chat.instance != (Object)null)
			{
				Chat.instance.ClearNpcText(((Component)this).gameObject);
			}
		}
	}
	public static class ChoreRules
	{
		public static DvergrCaste? RequiredCaste(Smelter station)
		{
			string text = (((Object)(object)station != (Object)null) ? ((Object)station).name.ToLowerInvariant() : string.Empty);
			if (text.Contains("smelter") || text.Contains("blast") || text.Contains("charcoal"))
			{
				return DvergrCaste.FireMage;
			}
			if (text.Contains("eitr") || text.Contains("spinning") || text.Contains("windmill"))
			{
				return DvergrCaste.IceMage;
			}
			return null;
		}

		public static string DisplayName(DvergrCaste caste)
		{
			return caste.Display();
		}
	}
	public class CommunionRite : MonoBehaviour
	{
		public const string ZdoKeyCommuning = "DE_Communing";

		private const float LashInterval = 1.25f;

		private const float DamageEpsilon = 0.5f;

		private const float ReleaseGraceSeconds = 0.5f;

		private const float PulseIntervalStart = 1f;

		private const float PulseIntervalEnd = 0.28f;

		private Character _target;

		private Player _player;

		private float _elapsed;

		private float _lashTimer;

		private float _lastPlayerHealth;

		private float _releaseGrace;

		private float _pulseTimer;

		private int _lashIndex;

		private StatusEffect _wishboneSE;

		private EffectList _pingEffect;

		private static readonly string[] LashLines = new string[4] { "The corruption writhes — hold fast.", "It fights the light within.", "The shadow claws to keep its hold.", "Damon's grip will not loosen easily." };

		public static CommunionRite Instance { get; private set; }

		public bool IsActive => (Object)(object)_target != (Object)null;

		private void Awake()
		{
			Instance = this;
		}

		public bool Begin(Character target, Player player)
		{
			if ((Object)(object)target == (Object)null || (Object)(object)player == (Object)null)
			{
				return false;
			}
			if ((Object)(object)_target != (Object)null)
			{
				return false;
			}
			ZNetView component = ((Component)target).GetComponent<ZNetView>();
			if ((Object)(object)component == (Object)null || !component.IsValid())
			{
				return false;
			}
			if (component.GetZDO().GetBool("DE_Communing", false))
			{
				MessageHud.instance.ShowMessage((MessageType)2, "Another is already in communion with it.", 0, (Sprite)null, false);
				return false;
			}
			component.ClaimOwnership();
			component.GetZDO().Set("DE_Communing", true);
			_target = target;
			_player = player;
			_elapsed = 0f;
			_lashTimer = 0f;
			_lashIndex = 0;
			_releaseGrace = 0f;
			_pulseTimer = 0f;
			_lastPlayerHealth = ((Character)player).GetHealth();
			PlayPulse((Character)(object)player);
			PlayPulse(target);
			MessageHud.instance.ShowMessage((MessageType)2, "You reach for the soul beneath the corruption…", 0, (Sprite)null, false);
			return true;
		}

		private void Update()
		{
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_target == (Object)null)
			{
				return;
			}
			if ((Object)(object)_target == (Object)null || _target.IsDead() || (Object)(object)_player == (Object)null)
			{
				Fail("The rite is broken.");
				return;
			}
			if (BlockHeld())
			{
				_releaseGrace = 0f;
			}
			else
			{
				_releaseGrace += Time.deltaTime;
				if (_releaseGrace >= 0.5f)
				{
					Fail("You lower your guard — the shadow reclaims it!");
					return;
				}
			}
			float num = Mathf.Max(1f, Plugin.CommunionMaxDistance.Value);
			if (Vector3.Distance(((Component)_player).transform.position, ((Component)_target).transform.position) > num)
			{
				Fail("You stray too far — the rite shatters!");
				return;
			}
			float health = ((Character)_player).GetHealth();
			if (Plugin.CommunionBreakOnDamage.Value && health < _lastPlayerHealth - 0.5f)
			{
				Fail("Struck mid-rite — the shadow reclaims it!");
				return;
			}
			_lastPlayerHealth = health;
			if (_target.GetHealthPercentage() > 0.5f)
			{
				Fail("It tears free of your grasp!");
				return;
			}
			_elapsed += Time.deltaTime;
			float num2 = Mathf.Clamp01(_elapsed / Mathf.Max(0.1f, Plugin.CommunionChannelSeconds.Value));
			float num3 = Mathf.Lerp(1f, 0.28f, num2);
			_pulseTimer += Time.deltaTime;
			if (_pulseTimer >= num3)
			{
				_pulseTimer = 0f;
				PlayPulse(_target);
				PlayPulse((Character)(object)_player);
			}
			_lashTimer += Time.deltaTime;
			if (_lashTimer >= 1.25f)
			{
				_lashTimer = 0f;
				MessageHud.instance.ShowMessage((MessageType)2, LashLines[_lashIndex % LashLines.Length], 0, (Sprite)null, false);
				_lashIndex++;
			}
			if (_elapsed >= Mathf.Max(0.1f, Plugin.CommunionChannelSeconds.Value))
			{
				Succeed();
			}
		}

		private void Succeed()
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			Character target = _target;
			Player player = _player;
			ClearLock(target);
			Reset();
			DvergrCaste dvergrCaste = CommunionService.DetectCaste(target);
			Plugin.Log.LogInfo((object)$"[recruit] rite complete — '{((Object)target).name}' detected as caste {dvergrCaste}.");
			if (CommunionService.TryRecruit(target, player, dvergrCaste))
			{
				TotemConversionService.PlaySummonVfx(((Component)target).transform.position + Vector3.up);
				MessageHud.instance.ShowMessage((MessageType)2, "The shadow's grip loosens — a " + dvergrCaste.Display() + " joins you.", 0, (Sprite)null, false);
			}
			else
			{
				MessageHud.instance.ShowMessage((MessageType)2, "The rite falters at the last moment.", 0, (Sprite)null, false);
			}
		}

		private void Fail(string message)
		{
			Character target = _target;
			Player player = _player;
			ClearLock(target);
			Reset();
			if ((Object)(object)target == (Object)null)
			{
				return;
			}
			MonsterAI component = ((Component)target).GetComponent<MonsterAI>();
			if ((Object)(object)component != (Object)null)
			{
				((BaseAI)component).SetAggravated(true, (AggravatedReason)0);
				((BaseAI)component).SetAlerted(true);
				if ((Object)(object)player != (Object)null)
				{
					component.SetTarget(((Component)player).GetComponent<Character>());
				}
			}
			MessageHud.instance.ShowMessage((MessageType)2, message, 0, (Sprite)null, false);
		}

		private static void ClearLock(Character target)
		{
			if (!((Object)(object)target == (Object)null))
			{
				ZNetView component = ((Component)target).GetComponent<ZNetView>();
				if ((Object)(object)component != (Object)null && component.IsValid() && component.IsOwner())
				{
					component.GetZDO().Set("DE_Communing", false);
				}
			}
		}

		private void Reset()
		{
			_target = null;
			_player = null;
			_elapsed = 0f;
			_lashTimer = 0f;
			_lashIndex = 0;
			_releaseGrace = 0f;
		}

		public static bool BlockHeld()
		{
			if (ZInput.instance != null)
			{
				return ZInput.GetButton("Block");
			}
			return false;
		}

		private StatusEffect WishboneSE()
		{
			if ((Object)(object)_wishboneSE != (Object)null)
			{
				return _wishboneSE;
			}
			if ((Object)(object)ObjectDB.instance == (Object)null)
			{
				return null;
			}
			GameObject itemPrefab = ObjectDB.instance.GetItemPrefab("Wishbone");
			ItemDrop val = (((Object)(object)itemPrefab != (Object)null) ? itemPrefab.GetComponent<ItemDrop>() : null);
			if ((Object)(object)val != (Object)null && val.m_itemData != null && val.m_itemData.m_shared != null)
			{
				_wishboneSE = val.m_itemData.m_shared.m_equipStatusEffect;
			}
			return _wishboneSE;
		}

		private EffectList PingEffect()
		{
			if (_pingEffect != null)
			{
				return _pingEffect;
			}
			StatusEffect obj = WishboneSE();
			SE_Finder val = (SE_Finder)(object)((obj is SE_Finder) ? obj : null);
			if ((Object)(object)val != (Object)null)
			{
				_pingEffect = val.m_pingEffectNear;
			}
			return _pingEffect;
		}

		private void PlayPulse(Character c)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)c == (Object)null))
			{
				PlayPulseAt(((Component)c).transform.position);
			}
		}

		public void PlayPulseAt(Vector3 pos)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			EffectList val = PingEffect();
			if (val != null)
			{
				val.Create(pos, Quaternion.identity, (Transform)null, 1f, -1);
			}
		}
	}
	public static class CommunionService
	{
		public const float SubdueHealthThreshold = 0.2f;

		public static DvergrCaste DetectCaste(Character target, bool log = true)
		{
			if ((Object)(object)target == (Object)null)
			{
				return DvergrCaste.Rogue;
			}
			Humanoid component = ((Component)target).GetComponent<Humanoid>();
			if ((Object)(object)component != (Object)null)
			{
				string[] array = new string[5]
				{
					ItemName(component.GetCurrentWeapon()),
					ItemName(component.m_rightItem),
					ItemName(component.m_hiddenRightItem),
					ItemName(component.m_leftItem),
					ItemName(component.m_hiddenLeftItem)
				};
				foreach (string text in array)
				{
					DvergrCaste? dvergrCaste = ClassifyByElement(text);
					if (dvergrCaste.HasValue)
					{
						if (log)
						{
							Plugin.Log.LogInfo((object)$"[recruit] caste {dvergrCaste.Value} from weapon slot '{text}'.");
						}
						return dvergrCaste.Value;
					}
				}
				Inventory inventory = component.GetInventory();
				if (inventory != null)
				{
					foreach (ItemData allItem in inventory.GetAllItems())
					{
						string text2 = ItemName(allItem);
						DvergrCaste? dvergrCaste2 = ((text2 != null && text2.ToLowerInvariant().Contains("staff")) ? ClassifyByElement(text2) : ((DvergrCaste?)null));
						if (dvergrCaste2.HasValue)
						{
							if (log)
							{
								Plugin.Log.LogInfo((object)$"[recruit] caste {dvergrCaste2.Value} from inventory item '{text2}'.");
							}
							return dvergrCaste2.Value;
						}
					}
				}
			}
			string name = ((Object)target).name;
			if (!string.IsNullOrEmpty(name))
			{
				if (name.IndexOf("Fire", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return DvergrCaste.FireMage;
				}
				if (name.IndexOf("Ice", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return DvergrCaste.IceMage;
				}
				if (name.IndexOf("Support", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return DvergrCaste.SupportMage;
				}
			}
			if (log)
			{
				LogDetectionMiss(target, component);
			}
			return DvergrCaste.Rogue;
		}

		private static DvergrCaste? ClassifyByElement(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return null;
			}
			string text = name.ToLowerInvariant();
			if (text.Contains("fire"))
			{
				return DvergrCaste.FireMage;
			}
			if (text.Contains("ice") || text.Contains("frost"))
			{
				return DvergrCaste.IceMage;
			}
			if (text.Contains("support") || text.Contains("heal") || text.Contains("nova") || text.Contains("blocker") || text.Contains("shield"))
			{
				return DvergrCaste.SupportMage;
			}
			return null;
		}

		private static string ItemName(ItemData item)
		{
			if (item == null)
			{
				return null;
			}
			if ((Object)(object)item.m_dropPrefab != (Object)null)
			{
				return ((Object)item.m_dropPrefab).name;
			}
			if (item.m_shared == null)
			{
				return null;
			}
			return item.m_shared.m_name;
		}

		private static void LogDetectionMiss(Character target, Humanoid humanoid)
		{
			string text = "(none)";
			if ((Object)(object)humanoid != (Object)null && humanoid.GetInventory() != null)
			{
				List<string> list = new List<string>();
				foreach (ItemData allItem in humanoid.GetInventory().GetAllItems())
				{
					list.Add(ItemName(allItem));
				}
				if (list.Count > 0)
				{
					text = string.Join(", ", list);
				}
			}
			Plugin.Log.LogInfo((object)("[recruit] No staff detected -> Rogue. prefab='" + ((Object)target).name + "', slots[" + Slots() + "], inventory=[" + text + "]."));
			string Slots()
			{
				if ((Object)(object)humanoid == (Object)null)
				{
					return "(no humanoid)";
				}
				return "cur='" + ItemName(humanoid.GetCurrentWeapon()) + "', right='" + ItemName(humanoid.m_rightItem) + "', hiddenRight='" + ItemName(humanoid.m_hiddenRightItem) + "', left='" + ItemName(humanoid.m_leftItem) + "', hiddenLeft='" + ItemName(humanoid.m_hiddenLeftItem) + "'";
			}
		}

		public static GameObject SpawnRecruited(DvergrCaste caste, int level, Player owner, Vector3 pos, float xp = 0f, string companionId = null)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ZNetScene.instance == (Object)null)
			{
				return null;
			}
			GameObject prefab = ZNetScene.instance.GetPrefab(CastePrefab(caste));
			if ((Object)(object)prefab == (Object)null && caste != DvergrCaste.Rogue)
			{
				prefab = ZNetScene.instance.GetPrefab("DvergerMage");
			}
			if ((Object)(object)prefab == (Object)null)
			{
				prefab = ZNetScene.instance.GetPrefab("Dverger");
			}
			if ((Object)(object)prefab == (Object)null)
			{
				return null;
			}
			GameObject val = Object.Instantiate<GameObject>(prefab, pos, Quaternion.identity);
			Character component = val.GetComponent<Character>();
			ZNetView component2 = val.GetComponent<ZNetView>();
			if ((Object)(object)component2 != (Object)null && component2.IsValid())
			{
				ZDO zDO = component2.GetZDO();
				zDO.Set("DE_Recruited", true);
				zDO.Set("DE_Caste", (int)caste);
				zDO.Set("DE_Level", Mathf.Clamp(level, 1, 10));
				zDO.Set("DE_Xp", Mathf.Max(0f, xp));
				if ((Object)(object)owner != (Object)null)
				{
					zDO.Set("DE_Owner", owner.GetPlayerID());
					zDO.Set("DE_OwnerName", owner.GetPlayerName());
				}
				if (!string.IsNullOrEmpty(companionId))
				{
					zDO.Set("DE_CompanionId", companionId);
				}
			}
			if ((Object)(object)component != (Object)null)
			{
				ApplyFreedState(component, ((Object)(object)owner != (Object)null) ? ((Component)owner).gameObject : null);
			}
			if ((Object)(object)val.GetComponent<DvergrCompanion>() == (Object)null)
			{
				val.AddComponent<DvergrCompanion>();
			}
			if ((Object)(object)val.GetComponent<ShipRideAI>() == (Object)null)
			{
				val.AddComponent<ShipRideAI>();
			}
			if ((Object)(object)val.GetComponent<CompanionInventory>() == (Object)null)
			{
				val.AddComponent<CompanionInventory>();
			}
			Plugin.Log.LogInfo((object)string.Format("[admin] Spawned recruited {0} (lv {1}) for {2}.", caste, level, ((Object)(object)owner != (Object)null) ? owner.GetPlayerName() : "?"));
			return val;
		}

		private static string CastePrefab(DvergrCaste caste)
		{
			return caste switch
			{
				DvergrCaste.FireMage => "DvergerMageFire", 
				DvergrCaste.IceMage => "DvergerMageIce", 
				DvergrCaste.SupportMage => "DvergerMageSupport", 
				_ => "Dverger", 
			};
		}

		public static bool IsSubduedDvergr(Character target)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Invalid comparison between Unknown and I4
			if ((Object)(object)target == (Object)null)
			{
				return false;
			}
			if ((int)target.m_faction != 10)
			{
				return false;
			}
			if (target.IsDead())
			{
				return false;
			}
			return target.GetHealthPercentage() <= 0.2f;
		}

		public static bool TryRecruit(Character target, Player recruiter, DvergrCaste caste)
		{
			if (!IsSubduedDvergr(target))
			{
				return false;
			}
			ApplyFreedState(target, ((Object)(object)recruiter != (Object)null) ? ((Component)recruiter).gameObject : null);
			DvergrCompanion dvergrCompanion = ((Component)target).GetComponent<DvergrCompanion>();
			if ((Object)(object)dvergrCompanion == (Object)null)
			{
				dvergrCompanion = ((Component)target).gameObject.AddComponent<DvergrCompanion>();
			}
			if ((Object)(object)((Component)target).GetComponent<ShipRideAI>() == (Object)null)
			{
				((Component)target).gameObject.AddComponent<ShipRideAI>();
			}
			if ((Object)(object)((Component)target).GetComponent<CompanionInventory>() == (Object)null)
			{
				((Component)target).gameObject.AddComponent<CompanionInventory>();
			}
			dvergrCompanion.SetCaste(caste);
			if ((Object)(object)recruiter != (Object)null)
			{
				dvergrCompanion.SetOwner(recruiter.GetPlayerID());
				dvergrCompanion.SetOwnerName(recruiter.GetPlayerName());
			}
			dvergrCompanion.EnsureCompanionId();
			ZNetView component = ((Component)target).GetComponent<ZNetView>();
			if ((Object)(object)component != (Object)null && component.IsValid())
			{
				component.GetZDO().Set("DE_Recruited", true);
			}
			Plugin.Log.LogInfo((object)string.Format("Dvergr {0} recruited by {1}.", caste, ((Object)(object)recruiter != (Object)null) ? recruiter.GetPlayerName() : "unknown"));
			ServerGuideBridge.RaiseRecruited(caste);
			BountyService.NotifyCommuned(target, recruiter);
			dvergrCompanion.AnnounceCapability();
			return true;
		}

		public static void RestoreCompanion(Character target)
		{
			if ((Object)(object)target == (Object)null)
			{
				return;
			}
			ZNetView component = ((Component)target).GetComponent<ZNetView>();
			if (!((Object)(object)component == (Object)null) && component.IsValid() && component.GetZDO().GetBool("DE_Recruited", false))
			{
				ApplyFreedState(target, null);
				if ((Object)(object)((Component)target).GetComponent<DvergrCompanion>() == (Object)null)
				{
					((Component)target).gameObject.AddComponent<DvergrCompanion>();
				}
				if ((Object)(object)((Component)target).GetComponent<ShipRideAI>() == (Object)null)
				{
					((Component)target).gameObject.AddComponent<ShipRideAI>();
				}
				if ((Object)(object)((Component)target).GetComponent<CompanionInventory>() == (Object)null)
				{
					((Component)target).gameObject.AddComponent<CompanionInventory>();
				}
				if (ChoreAI.HasPersistedChore(component) && (Object)(object)((Component)target).GetComponent<ChoreAI>() == (Object)null)
				{
					((Component)target).gameObject.AddComponent<ChoreAI>();
				}
			}
		}

		private static void ApplyFreedState(Character target, GameObject followTarget)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			target.m_faction = (Faction)0;
			NpcTalk component = ((Component)target).GetComponent<NpcTalk>();
			if ((Object)(object)component != (Object)null)
			{
				((Behaviour)component).enabled = false;
			}
			MonsterAI component2 = ((Component)target).GetComponent<MonsterAI>();
			if (!((Object)(object)component2 == (Object)null))
			{
				((BaseAI)component2).SetAggravated(false, (AggravatedReason)0);
				((BaseAI)component2).m_aggravatable = false;
				component2.m_attackPlayerObjects = false;
				component2.m_targetStatic = null;
				((BaseAI)component2).m_avoidWater = true;
				component2.SetTarget((Character)null);
				((BaseAI)component2).SetAlerted(false);
				((BaseAI)component2).SetHuntPlayer(false);
				if ((Object)(object)followTarget != (Object)null)
				{
					component2.SetFollowTarget(followTarget);
				}
			}
		}
	}
	public enum ConsumableKind
	{
		None,
		Food,
		HealthMead,
		ResistMead
	}
	public static class CompanionConsumables
	{
		public static ConsumableKind Classify(ItemData item)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Invalid comparison between Unknown and I4
			if (item?.m_shared == null)
			{
				return ConsumableKind.None;
			}
			if ((int)item.m_shared.m_itemType != 2)
			{
				return ConsumableKind.None;
			}
			if (item.m_shared.m_food > 0f)
			{
				return ConsumableKind.Food;
			}
			StatusEffect consumeStatusEffect = item.m_shared.m_consumeStatusEffect;
			SE_Stats val = (SE_Stats)(object)((consumeStatusEffect is SE_Stats) ? consumeStatusEffect : null);
			if ((Object)(object)val == (Object)null)
			{
				return ConsumableKind.None;
			}
			if (val.m_healthUpFront + val.m_healthOverTime > 0f)
			{
				return ConsumableKind.HealthMead;
			}
			if (GrantsResistance(val))
			{
				return ConsumableKind.ResistMead;
			}
			return ConsumableKind.None;
		}

		public static float HealAmount(ItemData item)
		{
			StatusEffect obj = item?.m_shared?.m_consumeStatusEffect;
			SE_Stats val = (SE_Stats)(object)((obj is SE_Stats) ? obj : null);
			if ((Object)(object)val == (Object)null)
			{
				return 0f;
			}
			return Mathf.Max(0f, val.m_healthUpFront + val.m_healthOverTime);
		}

		public static StatusEffect ConsumeEffect(ItemData item)
		{
			if (item?.m_shared == null)
			{
				return null;
			}
			return item.m_shared.m_consumeStatusEffect;
		}

		private static bool GrantsResistance(SE_Stats stats)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected I4, but got Unknown
			if (stats.m_mods == null)
			{
				return false;
			}
			foreach (DamageModPair mod in stats.m_mods)
			{
				DamageModifier modifier = mod.m_modifier;
				switch (modifier - 1)
				{
				case 0:
				case 2:
				case 4:
					return true;
				}
			}
			return false;
		}

		public static List<StatusEffect> ActiveResistEffects(Character c)
		{
			List<StatusEffect> list = new List<StatusEffect>();
			SEMan val = (((Object)(object)c != (Object)null) ? c.GetSEMan() : null);
			if (val == null)
			{
				return list;
			}
			foreach (StatusEffect statusEffect in val.GetStatusEffects())
			{
				SE_Stats val2 = (SE_Stats)(object)((statusEffect is SE_Stats) ? statusEffect : null);
				if (val2 != null && GrantsResistance(val2))
				{
					list.Add(statusEffect);
				}
			}
			return list;
		}
	}
	[RequireComponent(typeof(DvergrCompanion))]
	public class CompanionInventory : MonoBehaviour
	{
		public const int Columns = 4;

		public const int Rows = 2;

		public const float MaxWeight = 150f;

		private Container _container;

		private DvergrCompanion _companion;

		public Container Container => _container;

		public Inventory Inventory
		{
			get
			{
				if (!((Object)(object)_container != (Object)null))
				{
					return null;
				}
				return _container.GetInventory();
			}
		}

		public bool IsOverCapacity => TotalWeight() > 150f;

		public bool IsEmpty
		{
			get
			{
				if (Inventory != null)
				{
					return Inventory.NrOfItems() == 0;
				}
				return true;
			}
		}

		private void Awake()
		{
			_companion = ((Component)this).GetComponent<DvergrCompanion>();
			EnsureContainer();
			if ((Object)(object)((Component)this).GetComponent<CompanionInventoryAI>() == (Object)null)
			{
				((Component)this).gameObject.AddComponent<CompanionInventoryAI>();
			}
		}

		public void EnsureContainer()
		{
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Expected O, but got Unknown
			if (!((Object)(object)_container != (Object)null) || _container.GetInventory() == null)
			{
				_container = ((Component)this).GetComponent<Container>() ?? ((Component)this).gameObject.AddComponent<Container>();
				_container.m_name = InventoryTitle();
				_container.m_width = 4;
				_container.m_height = 2;
				_container.m_checkGuardStone = false;
				_container.m_autoDestroyEmpty = false;
				ZNetView component = ((Component)this).GetComponent<ZNetView>();
				if ((Object)(object)component != (Object)null && component.IsValid())
				{
					Inventory val = new Inventory(_container.m_name, (Sprite)null, 4, 2);
					val.m_onChanged = _container.OnContainerChanged;
					_container.m_inventory = val;
					_container.Load();
				}
			}
		}

		public string InventoryTitle()
		{
			return (((Object)(object)_companion != (Object)null) ? _companion.DisplayName : "Dvergr") + "'s pack";
		}

		public void RefreshTitle()
		{
			if ((Object)(object)_container != (Object)null)
			{
				_container.m_name = InventoryTitle();
			}
		}

		public float TotalWeight()
		{
			if (Inventory == null)
			{
				return 0f;
			}
			return Inventory.GetTotalWeight();
		}

		public bool Holds(ItemData item)
		{
			if (item?.m_shared == null || Inventory == null)
			{
				return false;
			}
			foreach (ItemData allItem in Inventory.GetAllItems())
			{
				if (allItem?.m_shared != null && allItem.m_shared.m_name == item.m_shared.m_name)
				{
					return true;
				}
			}
			return false;
		}

		public ItemData FindItem(Func<ItemData, bool> match)
		{
			if (Inventory == null)
			{
				return null;
			}
			foreach (ItemData allItem in Inventory.GetAllItems())
			{
				if (allItem != null && match(allItem))
				{
					return allItem;
				}
			}
			return null;
		}

		public List<ItemData> Items()
		{
			if (Inventory == null)
			{
				return new List<ItemData>();
			}
			return Inventory.GetAllItems();
		}

		public bool ConsumeOne(ItemData item)
		{
			if (item == null || Inventory == null)
			{
				return false;
			}
			return Inventory.RemoveItem(item, 1);
		}
	}
	[RequireComponent(typeof(DvergrCompanion))]
	[RequireComponent(typeof(CompanionInventory))]
	public class CompanionInventoryAI : MonoBehaviour
	{
		private const float TickInterval = 1f;

		private const float PickupRange = 8f;

		private const float MeadHealBelowFraction = 0.35f;

		private const float MeadHealUntilFraction = 0.9f;

		private DvergrCompanion _companion;

		private CompanionInventory _inv;

		private Character _character;

		private MonsterAI _ai;

		private ZNetView _znv;

		private float _tick;

		private float _foodPeak;

		private float _foodApplied;

		private float _foodDuration;

		private float _foodElapsed;

		private bool _healing;

		private void Awake()
		{
			_companion = ((Component)this).GetComponent<DvergrCompanion>();
			_inv = ((Component)this).GetComponent<CompanionInventory>();
			_character = ((Component)this).GetComponent<Character>();
			_ai = ((Component)this).GetComponent<MonsterAI>();
			_znv = ((Component)this).GetComponent<ZNetView>();
		}

		private void Update()
		{
			if ((Object)(object)_character == (Object)null || _character.IsDead())
			{
				return;
			}
			if (!((Object)(object)_znv == (Object)null) && _znv.IsValid() && !_znv.IsOwner())
			{
				if ((Object)(object)_companion != (Object)null && (Object)(object)_inv != (Object)null)
				{
					_companion.IsEncumbered = _inv.IsOverCapacity;
				}
				return;
			}
			TickFoodBuff(Time.deltaTime);
			bool isOverCapacity = _inv.IsOverCapacity;
			if (_companion.DuelMode)
			{
				_companion.IsEncumbered = isOverCapacity;
			}
			else
			{
				_companion.ApplyEncumbrance(isOverCapacity);
			}
			_tick += Time.deltaTime;
			if (!(_tick < 1f))
			{
				_tick = 0f;
				TickConsumption();
				if (!isOverCapacity && (!((Object)(object)_ai != (Object)null) || (!((BaseAI)_ai).IsAlerted() && !((BaseAI)_ai).HaveTarget())) && !_companion.ChoreActive && !_companion.DuelMode && !_inv.IsEmpty)
				{
					TickPickup();
				}
			}
		}

		private void TickPickup()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			Inventory inventory = _inv.Inventory;
			if (inventory == null)
			{
				return;
			}
			Collider[] array = Physics.OverlapSphere(((Component)this).transform.position, 8f);
			foreach (Collider val in array)
			{
				ItemDrop val2 = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponentInParent<ItemDrop>() : null);
				if ((Object)(object)val2 == (Object)null || !val2.CanPickup(false))
				{
					continue;
				}
				ZNetView component = ((Component)val2).GetComponent<ZNetView>();
				if ((Object)(object)component == (Object)null || !component.IsValid())
				{
					continue;
				}
				ItemData itemData = val2.m_itemData;
				if (itemData?.m_shared != null && _inv.Holds(itemData))
				{
					if (inventory.CanAddItem(itemData, itemData.m_stack))
					{
						inventory.AddItem(itemData.Clone());
						component.ClaimOwnership();
						ZNetScene.instance.Destroy(((Component)val2).gameObject);
					}
					break;
				}
			}
		}

		private void TickConsumption()
		{
			if (_inv.Inventory == null)
			{
				return;
			}
			ItemData val = _inv.FindItem((ItemData it) => CompanionConsumables.Classify(it) == ConsumableKind.ResistMead && !HasEffect(CompanionConsumables.ConsumeEffect(it)));
			if (val != null)
			{
				DrinkStatusMead(val);
				return;
			}
			float healthPercentage = _character.GetHealthPercentage();
			if (healthPercentage < 0.35f)
			{
				_healing = true;
			}
			else if (healthPercentage > 0.9f)
			{
				_healing = false;
			}
			if (_healing)
			{
				ItemData val2 = _inv.FindItem((ItemData it) => CompanionConsumables.Classify(it) == ConsumableKind.HealthMead);
				if (val2 != null)
				{
					float num = CompanionConsumables.HealAmount(val2);
					if (_inv.ConsumeOne(val2))
					{
						_character.Heal(num, true);
						PlayConsumeEffects(val2);
					}
					return;
				}
				_healing = false;
			}
			if (_foodApplied <= 0f && _foodElapsed >= _foodDuration)
			{
				ItemData val3 = _inv.FindItem((ItemData it) => CompanionConsumables.Classify(it) == ConsumableKind.Food);
				if (val3 != null)
				{
					EatFood(val3);
				}
			}
		}

		private void DrinkStatusMead(ItemData mead)
		{
			StatusEffect val = CompanionConsumables.ConsumeEffect(mead);
			if (!((Object)(object)val == (Object)null) && _inv.ConsumeOne(mead))
			{
				_character.GetSEMan().AddStatusEffect(val, true, 0, 0f);
				PlayConsumeEffects(mead);
			}
		}

		private bool HasEffect(StatusEffect se)
		{
			if ((Object)(object)se == (Object)null || (Object)(object)_character == (Object)null)
			{
				return false;
			}
			return _character.GetSEMan().HaveStatusEffect(se.NameHash());
		}

		private void PlayConsumeEffects(ItemData item)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			StatusEffect val = CompanionConsumables.ConsumeEffect(item);
			EffectList val2 = (((Object)(object)val != (Object)null) ? val.m_startEffects : null);
			if (val2 != null)
			{
				val2.Create(((Component)this).transform.position, ((Component)this).transform.rotation, ((Component)this).transform, 1f, -1);
			}
		}

		private void EatFood(ItemData food)
		{
			if (_inv.ConsumeOne(food))
			{
				_foodPeak = food.m_shared.m_food;
				_foodDuration = Mathf.Max(1f, food.m_shared.m_foodBurnTime);
				_foodElapsed = 0f;
				ApplyFoodBonus(_foodPeak);
				_companion.IsFed = true;
				_companion.FedIcon = ((food.m_shared.m_icons != null && food.m_shared.m_icons.Length != 0) ? food.m_shared.m_icons[0] : null);
				PlayConsumeEffects(food);
			}
		}

		private void TickFoodBuff(float dt)
		{
			if (!(_foodApplied <= 0f) || !(_foodElapsed >= _foodDuration))
			{
				_foodElapsed += dt;
				if (_foodElapsed >= _foodDuration)
				{
					ExpireFood();
					return;
				}
				float num = _foodElapsed / _foodDuration;
				float num2 = ((num <= 0.5f) ? 1f : Mathf.Clamp01(1f - (num - 0.5f) / 0.5f));
				ApplyFoodBonus(_foodPeak * num2);
			}
		}

		private void ApplyFoodBonus(float target)
		{
			if ((Object)(object)_character == (Object)null)
			{
				return;
			}
			float num = target - _foodApplied;
			if (!(Mathf.Abs(num) < 0.01f))
			{
				float num2 = Mathf.Max(1f, _character.GetMaxHealth() + num);
				_character.SetMaxHealth(num2);
				if (num > 0f)
				{
					_character.Heal(num, false);
				}
				else if (_character.GetHealth() > num2)
				{
					_character.SetHealth(num2);
				}
				_foodApplied = target;
			}
		}

		private void ExpireFood()
		{
			if (_foodApplied > 0f && (Object)(object)_character != (Object)null)
			{
				float num = Mathf.Max(1f, _character.GetMaxHealth() - _foodApplied);
				_character.SetMaxHealth(num);
				if (_character.GetHealth() > num)
				{
					_character.SetHealth(num);
				}
			}
			_foodApplied = 0f;
			_foodPeak = 0f;
			_foodElapsed = 0f;
			_foodDuration = 0f;
			if ((Object)(object)_companion != (Object)null)
			{
				_companion.IsFed = false;
				_companion.FedIcon = null;
			}
		}
	}
	public class CompanionInventoryGui : MonoBehaviour
	{
		private static CompanionInventoryGui _instance;

		private DvergrCompanion _openCompanion;

		private CompanionInventory _openInventory;

		private Character _openCharacter;

		private TMP_InputField _nameField;

		private TMP_Text _hpText;

		private bool _cloneFailed;

		public static bool IsTyping
		{
			get
			{
				if ((Object)(object)_instance != (Object)null && (Object)(object)_instance._nameField != (Object)null)
				{
					return _instance._nameField.isFocused;
				}
				return false;
			}
		}

		public static void Open(DvergrCompanion companion, CompanionInventory inventory)
		{
			if (!((Object)(object)_instance == (Object)null) && !((Object)(object)companion == (Object)null) && !((Object)(object)inventory == (Object)null) && !((Object)(object)InventoryGui.instance == (Object)null))
			{
				inventory.EnsureContainer();
				inventory.RefreshTitle();
				if (!((Object)(object)inventory.Container == (Object)null))
				{
					InventoryGui.instance.Show(inventory.Container, 0);
					_instance._openCompanion = companion;
					_instance._openInventory = inventory;
					_instance._openCharacter = ((Component)companion).GetComponent<Character>();
					_instance.BuildWidgets();
					_instance.ShowWidgets(show: true);
					_instance.Refresh();
				}
			}
		}

		private void Awake()
		{
			_instance = this;
		}

		private void Update()
		{
			if (!((Object)(object)_openCompanion == (Object)null))
			{
				InventoryGui instance = InventoryGui.instance;
				if (!((Object)(object)instance != (Object)null) || !InventoryGui.IsVisible() || !((Object)(object)instance.m_currentContainer != (Object)null) || !((Object)(object)_openInventory != (Object)null) || !((Object)(object)instance.m_currentContainer == (Object)(object)_openInventory.Container) || !((Object)(object)_openCharacter != (Object)null) || _openCharacter.IsDead())
				{
					ShowWidgets(show: false);
					_openCompanion = null;
					_openInventory = null;
					_openCharacter = null;
				}
				else
				{
					Refresh();
				}
			}
		}

		private void Refresh()
		{
			if ((Object)(object)_nameField != (Object)null && !_nameField.isFocused)
			{
				_nameField.SetTextWithoutNotify(_openCompanion.DisplayName);
			}
			if ((Object)(object)_hpText != (Object)null && (Object)(object)_openCharacter != (Object)null)
			{
				float num = Mathf.Ceil(_openCharacter.GetHealth());
				float num2 = Mathf.Ceil(_openCharacter.GetMaxHealth());
				string arg = (_openCompanion.IsFed ? "#FFD24A" : "#FFFFFF");
				_hpText.text = $"<color={arg}>HP {num:0} / {num2:0}</color>";
			}
		}

		private void BuildWidgets()
		{
			if (_cloneFailed)
			{
				return;
			}
			RectTransform val = (((Object)(object)InventoryGui.instance != (Object)null) ? InventoryGui.instance.m_container : null);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			try
			{
				EnsureNameField(val);
				EnsureHpText(val);
			}
			catch (Exception ex)
			{
				_cloneFailed = true;
				Plugin.Log.LogWarning((object)("[inventory] Could not build companion panel widgets: " + ex.Message));
			}
		}

		private void EnsureNameField(RectTransform panel)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_nameField != (Object)null)
			{
				return;
			}
			GuiInputField val = (((Object)(object)TextInput.instance != (Object)null) ? TextInput.instance.m_inputField : null);
			if (!((Object)(object)val == (Object)null))
			{
				GameObject val2 = Object.Instantiate<GameObject>(((Component)val).gameObject, (Transform)(object)panel);
				((Object)val2).name = "CompanionNameField";
				RectTransform component = val2.GetComponent<RectTransform>();
				if ((Object)(object)component != (Object)null)
				{
					Park(component, new Vector2(18f, -44f), new Vector2(210f, 28f));
				}
				_nameField = val2.GetComponent<TMP_InputField>();
				if ((Object)(object)_nameField == (Object)null)
				{
					Object.Destroy((Object)(object)val2);
					return;
				}
				((UnityEventBase)_nameField.onEndEdit).RemoveAllListeners();
				((UnityEvent<string>)(object)_nameField.onEndEdit).AddListener((UnityAction<string>)OnNameSubmitted);
				_nameField.characterLimit = 24;
			}
		}

		private void EnsureHpText(RectTransform panel)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_hpText != (Object)null)
			{
				return;
			}
			TMP_Text val = (((Object)(object)InventoryGui.instance != (Object)null) ? InventoryGui.instance.m_containerWeight : null);
			if (!((Object)(object)val == (Object)null))
			{
				GameObject val2 = Object.Instantiate<GameObject>(((Component)val).gameObject, (Transform)(object)panel);
				((Object)val2).name = "CompanionHpText";
				RectTransform component = val2.GetComponent<RectTransform>();
				if ((Object)(object)component != (Object)null)
				{
					Park(component, new Vector2(236f, -44f), new Vector2(210f, 28f));
				}
				_hpText = val2.GetComponent<TMP_Text>();
				if ((Object)(object)_hpText != (Object)null)
				{
					_hpText.alignment = (TextAlignmentOptions)513;
					_hpText.enableAutoSizing = false;
					_hpText.fontSize = 18f;
					_hpText.richText = true;
				}
			}
		}

		private static void Park(RectTransform rt, Vector2 anchoredPos, Vector2 size)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			rt.anchorMin = new Vector2(0f, 1f);
			rt.anchorMax = new Vector2(0f, 1f);
			rt.pivot = new Vector2(0f, 1f);
			rt.anchoredPosition = anchoredPos;
			rt.sizeDelta = size;
		}

		private void ShowWidgets(bool show)
		{
			if ((Object)(object)_nameField != (Object)null)
			{
				((Component)_nameField).gameObject.SetActive(show);
			}
			if ((Object)(object)_hpText != (Object)null)
			{
				((Component)_hpText).gameObject.SetActive(show);
			}
		}

		private void OnNameSubmitted(string text)
		{
			if (!((Object)(object)_openCompanion == (Object)null) && !string.IsNullOrWhiteSpace(text) && !(text == _openCompanion.DisplayName))
			{
				_openCompanion.SetName(text);
				if ((Object)(object)_openInventory != (Object)null)
				{
					_openInventory.RefreshTitle();
				}
			}
		}
	}
	public class CompanionMapPins : MonoBehaviour
	{
		private const float UpdateInterval = 0.25f;

		private readonly Dictionary<DvergrCompanion, PinData> _pins = new Dictionary<DvergrCompanion, PinData>();

		private readonly HashSet<DvergrCompanion> _seen = new HashSet<DvergrCompanion>();

		private readonly List<DvergrCompanion> _stale = new List<DvergrCompanion>();

		private Minimap _boundMap;

		private float _timer;

		private void Update()
		{
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			Minimap instance = Minimap.instance;
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)instance == (Object)null || (Object)(object)localPlayer == (Object)null || !Plugin.ShowMapPins.Value)
			{
				if (_pins.Count > 0)
				{
					if ((Object)(object)instance == (Object)null)
					{
						_pins.Clear();
					}
					else
					{
						RemoveAll(instance);
					}
				}
				_boundMap = instance;
				return;
			}
			if ((Object)(object)_boundMap != (Object)(object)instance)
			{
				_pins.Clear();
				_boundMap = instance;
			}
			_timer += Time.deltaTime;
			if (_timer < 0.25f)
			{
				return;
			}
			_timer = 0f;
			Color color = PinColor();
			float scale = Mathf.Clamp(Plugin.CompanionPinScale.Value, 0.2f, 2f);
			_seen.Clear();
			foreach (DvergrCompanion item in DvergrCompanion.All)
			{
				if ((Object)(object)item == (Object)null || item.OwnerId == 0L || !item.IsOwner(localPlayer))
				{
					continue;
				}
				_seen.Add(item);
				if (_pins.TryGetValue(item, out var value) && value != null)
				{
					value.m_pos = ((Component)item).transform.position;
					if (value.m_name != item.DisplayName)
					{
						value.m_name = item.DisplayName;
					}
				}
				else
				{
					value = instance.AddPin(((Component)item).transform.position, (PinType)10, item.DisplayName, false, false, 0L, default(PlatformUserID));
					_pins[item] = value;
				}
				StylePin(value, color, scale);
			}
			_stale.Clear();
			foreach (KeyValuePair<DvergrCompanion, PinData> pin in _pins)
			{
				if (!_seen.Contains(pin.Key))
				{
					_stale.Add(pin.Key);
				}
			}
			foreach (DvergrCompanion item2 in _stale)
			{
				if (_pins.TryGetValue(item2, out var value2) && value2 != null)
				{
					instance.RemovePin(value2);
				}
				_pins.Remove(item2);
			}
		}

		private void RemoveAll(Minimap map)
		{
			foreach (KeyValuePair<DvergrCompanion, PinData> pin in _pins)
			{
				if (pin.Value != null)
				{
					map.RemovePin(pin.Value);
				}
			}
			_pins.Clear();
		}

		private static void StylePin(PinData pin, Color color, float scale)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			Image val = pin?.m_iconElement;
			if (!((Object)(object)val == (Object)null))
			{
				((Graphic)val).color = color;
				((Transform)((Graphic)val).rectTransform).localScale = new Vector3(scale, scale, 1f);
			}
		}

		private static Color PinColor()
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			string text = Plugin.CompanionPinColor.Value ?? string.Empty;
			if (!text.StartsWith("#"))
			{
				text = "#" + text;
			}
			Color result = default(Color);
			if (!ColorUtility.TryParseHtmlString(text, ref result))
			{
				return new Color(1f, 0.72f, 0.3f);
			}
			return result;
		}

		public static void AddDeathMarker(string companionName, Vector3 pos)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			if (Plugin.ShowDeathMarker != null && Plugin.ShowDeathMarker.Value)
			{
				Minimap instance = Minimap.instance;
				if (!((Object)(object)instance == (Object)null))
				{
					string text = (string.IsNullOrEmpty(companionName) ? "Fallen companion" : companionName);
					instance.AddPin(pos, (PinType)4, text, true, false, 0L, default(PlatformUserID));
					Plugin.Log.LogInfo((object)("[map] death marker placed for '" + text + "'."));
				}
			}
		}
	}
	[HarmonyPatch(typeof(TeleportWorld), "Teleport")]
	public static class CompanionPortalPatch
	{
		public static void Postfix(Player player, bool __runOriginal)
		{
			if (__runOriginal && !((Object)(object)player == (Object)null) && !((Object)(object)player != (Object)(object)Player.m_localPlayer) && ((Character)player).IsTeleporting())
			{
				CompanionTeleport.FollowOwnerThroughPortal(player);
			}
		}
	}
	[HarmonyPatch(typeof(TeleportWorld), "Teleport")]
	public static class CompanionPortalBlockPatch
	{
		private static float _lastMsg = -999f;

		public static bool Prefix(TeleportWorld __instance, Player player)
		{
			if ((Object)(object)player == (Object)null || (Object)(object)player != (Object)(object)Player.m_localPlayer)
			{
				return true;
			}
			if ((Object)(object)__instance == (Object)null || ((Object)__instance).name.IndexOf("portal_wood", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return true;
			}
			if (CompanionTeleport.TryFindPortalBlocker(player, out var companionName, out var itemName))
			{
				if (Time.time - _lastMsg > 2.5f)
				{
					_lastMsg = Time.time;
					((Character)player).Message((MessageType)2, companionName + " is carrying " + itemName + " — you can't take it through the portal.", 0, (Sprite)null);
				}
				return false;
			}
			return true;
		}
	}
	internal static class CompanionTeleport
	{
		private const float GatherRange = 60f;

		public static bool TryFindPortalBlocker(Player owner, out string companionName, out string itemName)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			companionName = null;
			itemName = null;
			if ((Object)(object)owner == (Object)null)
			{
				return false;
			}
			long playerID = owner.GetPlayerID();
			Vector3 position = ((Component)owner).transform.position;
			foreach (DvergrCompanion item in DvergrCompanion.All)
			{
				if ((Object)(object)item == (Object)null || item.Stance != CompanionStance.Follow || item.OwnerId == 0L || item.OwnerId != playerID || item.ChoreActive || item.DuelMode || item.IsFeral)
				{
					continue;
				}
				Character component = ((Component)item).GetComponent<Character>();
				if ((Object)(object)component == (Object)null || component.IsDead() || Vector3.Distance(((Component)component).transform.position, position) > 60f)
				{
					continue;
				}
				CompanionInventory component2 = ((Component)item).GetComponent<CompanionInventory>();
				Inventory val = (((Object)(object)component2 != (Object)null) ? component2.Inventory : null);
				if (val == null)
				{
					continue;
				}
				foreach (ItemData allItem in val.GetAllItems())
				{
					if (allItem?.m_shared != null && !allItem.m_shared.m_teleportable)
					{
						companionName = item.DisplayName;
						itemName = ((Localization.instance != null) ? Localization.instance.Localize(allItem.m_shared.m_name) : allItem.m_shared.m_name);
						return true;
					}
				}
			}
			return false;
		}

		public static void FollowOwnerThroughPortal(Player owner)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			Vector3 teleportTargetPos = owner.m_teleportTargetPos;
			Quaternion teleportTargetRot = owner.m_teleportTargetRot;
			Vector3 teleportFromPos = owner.m_teleportFromPos;
			long playerID = owner.GetPlayerID();
			int num = 0;
			foreach (DvergrCompanion item in DvergrCompanion.All)
			{
				if (!((Object)(object)item == (Object)null) && item.Stance == CompanionStance.Follow && item.OwnerId != 0L && item.OwnerId == playerID && !item.ChoreActive && !item.DuelMode && !item.IsFeral)
				{
					Character component = ((Component)item).GetComponent<Character>();
					if (!((Object)(object)component == (Object)null) && !component.IsDead() && !(Vector3.Distance(((Component)component).transform.position, teleportFromPos) > 60f))
					{
						TeleportCompanion(component, teleportTargetPos + SpreadOffset(num), teleportTargetRot);
						num++;
					}
				}
			}
			if (num > 0)
			{
				Plugin.Log.LogInfo((object)$"[portal] Brought {num} companion(s) through the portal for {owner.GetPlayerName()}.");
			}
		}

		private static void TeleportCompanion(Character ch, Vector3 pos, Quaternion rot)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			ZNetView component = ((Component)ch).GetComponent<ZNetView>();
			if ((Object)(object)component != (Object)null && component.IsValid())
			{
				component.ClaimOwnership();
				component.GetZDO().SetPosition(pos);
			}
			((Component)ch).transform.SetPositionAndRotation(pos, rot);
			if ((Object)(object)ch.m_body != (Object)null)
			{
				ch.m_body.position = pos;
				ch.m_body.rotation = rot;
			}
		}

		private static Vector3 SpreadOffset(int index)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			float num = 2.399963f * (float)index;
			float num2 = 1.2f + 0.5f * (float)index;
			return new Vector3(Mathf.Cos(num) * num2, 0f, Mathf.Sin(num) * num2);
		}
	}
	[HarmonyPatch(typeof(MonsterAI), "Start")]
	public static class CompanionRestorePatch
	{
		public static void Postfix(MonsterAI __instance)
		{
			CommunionService.RestoreCompanion(((Component)__instance).GetComponent<Character>());
		}
	}
	public class ContainerPanelPositioner : MonoBehaviour
	{
		private const float DefaultRowsBelow = 2f;

		private const float FallbackRowHeight = 68f;

		private const float ScreenMargin = 48f;

		private const string AutoValue = "auto";

		private RectTransform _panel;

		private Vector2 _basePos;

		private Vector2 _offset;

		private bool _applied;

		private bool _dragging;

		private string _lastConfigValue;

		private bool _parseWarned;

		private ContainerDragSurface _surface;

		private static int _biomeLords = -1;

		private static bool _decisionLogged;

		public static bool Enabled
		{
			get
			{
				bool flag = Plugin.MoveContainerPanel == null || Plugin.MoveContainerPanel.Value;
				bool flag2 = BiomeLordsLoaded();
				bool flag3 = flag && !flag2;
				if (!_decisionLogged)
				{
					_decisionLogged = true;
					Plugin.Log.LogInfo((object)("[inventory] container-panel positioning: " + (flag3 ? "ON" : "OFF") + " " + $"(config={flag}, BiomeLords={flag2}). BiomeLords ⇒ we leave the chest UI position to it."));
				}
				return flag3;
			}
		}

		public static bool BiomeLordsLoaded()
		{
			if (_biomeLords < 0)
			{
				_biomeLords = 0;
				foreach (KeyValuePair<string, PluginInfo> pluginInfo in Chainloader.PluginInfos)
				{
					string obj = pluginInfo.Key ?? string.Empty;
					PluginInfo value = pluginInfo.Value;
					object obj2;
					if (value == null)
					{
						obj2 = null;
					}
					else
					{
						BepInPlugin metadata = value.Metadata;
						obj2 = ((metadata != null) ? metadata.Name : null);
					}
					if (obj2 == null)
					{
						obj2 = string.Empty;
					}
					string text = (string)obj2;
					if (obj.IndexOf("biomelord", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("biomelord", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						_biomeLords = 1;
						break;
					}
				}
			}
			return _biomeLords == 1;
		}

		private void Update()
		{
			if (!Enabled)
			{
				Release();
				return;
			}
			InventoryGui instance = InventoryGui.instance;
			RectTransform val = (((Object)(object)instance != (Object)null) ? instance.m_container : null);
			if (!((Object)(object)val == (Object)null) && ((Component)val).gameObject.activeInHierarchy)
			{
				Track(val);
				EnsureSurface();
				SyncFromConfig(instance);
				if (!_dragging)
				{
					Apply();
				}
			}
		}

		private void Track(RectTransform container)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_panel == (Object)(object)container))
			{
				_panel = container;
				_basePos = container.anchoredPosition;
				_applied = false;
				_dragging = false;
				_surface = null;
				_lastConfigValue = null;
			}
		}

		private void SyncFromConfig(InventoryGui gui)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			string text = ((Plugin.ContainerPanelOffset != null) ? Plugin.ContainerPanelOffset.Value : "auto");
			if (!(text == _lastConfigValue))
			{
				_lastConfigValue = text;
				_offset = ParseOffset(text, gui);
			}
		}

		private Vector2 ParseOffset(string raw, InventoryGui gui)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			raw = (raw ?? string.Empty).Trim();
			if (raw.Length == 0 || raw.Equals("auto", StringComparison.OrdinalIgnoreCase))
			{
				return DefaultOffset(gui);
			}
			string[] array = raw.Split(new char[3] { ',', ';', ' ' }, StringSplitOptions.RemoveEmptyEntries);
			if (array.Length == 2 && float.TryParse(array[0], NumberStyles.Float, CultureInfo.InvariantCulture, out var result) && float.TryParse(array[1], NumberStyles.Float, CultureInfo.InvariantCulture, out var result2))
			{
				return new Vector2(result, result2);
			}
			if (!_parseWarned)
			{
				_parseWarned = true;
				Plugin.Log.LogWarning((object)("[inventory] ContainerPanelOffset '" + raw + "' isn't 'auto' or 'x,y' — using the default position."));
			}
			return DefaultOffset(gui);
		}

		private static Vector2 DefaultOffset(InventoryGui gui)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			float num = (((Object)(object)gui != (Object)null && (Object)(object)gui.m_playerGrid != (Object)null && gui.m_playerGrid.m_elementSpace > 0f) ? gui.m_playerGrid.m_elementSpace : 68f);
			return new Vector2(0f, -2f * num);
		}

		private void Apply()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_panel == (Object)null))
			{
				_panel.anchoredPosition = _basePos + _offset;
				_applied = true;
				ClampToScreen();
			}
		}

		private void ClampToScreen()
		{
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_panel == (Object)null))
			{
				Vector3[] array = (Vector3[])(object)new Vector3[4];
				_panel.GetWorldCorners(array);
				float x = array[0].x;
				float x2 = array[2].x;
				float y = array[0].y;
				float y2 = array[1].y;
				float num = 0f;
				float num2 = 0f;
				if (x2 < 48f)
				{
					num = 48f - x2;
				}
				else if (x > (float)Screen.width - 48f)
				{
					num = (float)Screen.width - 48f - x;
				}
				if (y2 < 48f)
				{
					num2 = 48f - y2;
				}
				else if (y > (float)Screen.height - 48f)
				{
					num2 = (float)Screen.height - 48f - y;
				}
				if (num != 0f || num2 != 0f)
				{
					Vector2 val = new Vector2(num, num2) / CanvasScale();
					_offset += val;
					_panel.anchoredPosition = _basePos + _offset;
				}
			}
		}

		private float CanvasScale()
		{
			Canvas val = (((Object)(object)_panel != (Object)null) ? ((Component)_panel).GetComponentInParent<Canvas>() : null);
			float num = (((Object)(object)val != (Object)null) ? val.scaleFactor : 1f);
			if (!(num > 0.0001f))
			{
				return 1f;
			}
			return num;
		}

		private void Release()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_panel != (Object)null && _applied)
			{
				_panel.anchoredPosition = _basePos;
				_applied = false;
			}
			if ((Object)(object)_surface != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)_surface).gameObject);
			}
			_surface = null;
			_dragging = false;
		}

		private void EnsureSurface()
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_surface != (Object)null) && !((Object)(object)_panel == (Object)null))
			{
				GameObject val = new GameObject("LSII_ContainerDragSurface", new Type[1] { typeof(RectTransform) });
				RectTransform val2 = (RectTransform)val.transform;
				((Transform)val2).SetParent((Transform)(object)_panel, false);
				val2.anchorMin = Vector2.zero;
				val2.anchorMax = Vector2.one;
				val2.offsetMin = Vector2.zero;
				val2.offsetMax = Vector2.zero;
				Image val3 = val.AddComponent<Image>();
				((Graphic)val3).color = Color.clear;
				((Graphic)val3).raycastTarget = true;
				((Transform)val2).SetAsFirstSibling();
				_surface = val.AddComponent<ContainerDragSurface>();
				_surface.Bind(this, val3);
			}
		}

		internal void BeginDrag()
		{
			_dragging = true;
		}

		internal void DragBy(Vector2 screenDelta)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_panel == (Object)null))
			{
				_offset += screenDelta / CanvasScale();
				_panel.anchoredPosition = _basePos + _offset;
				_applied = true;
				ClampToScreen();
			}
		}

		internal void EndDrag()
		{
			_dragging = false;
			if (Plugin.ContainerPanelOffset != null)
			{
				string value = (_lastConfigValue = string.Format(CultureInfo.InvariantCulture, "{0:0.##},{1:0.##}", _offset.x, _offset.y));
				Plugin.ContainerPanelOffset.Value = value;
			}
		}
	}
	public class ContainerDragSurface : MonoBehaviour, IBeginDragHandler, IEventSystemHandler, IDragHandler, IEndDragHandler, IPointerEnterHandler, IPointerExitHandler
	{
		private static readonly Color Hover = new Color(1f, 1f, 1f, 0.05f);

		private ContainerPanelPositioner _owner;

		private Image _image;

		internal void Bind(ContainerPanelPositioner owner, Image image)
		{
			_owner = owner;
			_image = image;
		}

		public void OnBeginDrag(PointerEventData eventData)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if ((int)eventData.button == 0)
			{
				_owner?.BeginDrag();
			}
		}

		public void OnDrag(PointerEventData eventData)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if ((int)eventData.button == 0)
			{
				_owner?.DragBy(eventData.delta);
			}
		}

		public void OnEndDrag(PointerEventData eventData)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if ((int)eventData.button == 0)
			{
				_owner?.EndDrag();
			}
		}

		public void OnPointerEnter(PointerEventData eventData)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_image != (Object)null)
			{
				((Graphic)_image).color = Hover;
			}
		}

		public void OnPointerExit(PointerEventData eventData)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_image != (Object)null)
			{
				((Graphic)_image).color = Color.clear;
			}
		}
	}
	public enum DvergrCaste
	{
		Rogue,
		FireMage,
		IceMage,
		SupportMage
	}
	public static class DvergrCasteExtensions
	{
		public static string Display(this DvergrCaste caste)
		{
			return caste switch
			{
				DvergrCaste.FireMage => "Fire Mage", 
				DvergrCaste.IceMage => "Ice Mage", 
				DvergrCaste.SupportMage => "Support Mage", 
				_ => "Rogue", 
			};
		}
	}
	public class DvergrCompanion : MonoBehaviour, TextReceiver
	{
		public enum DuelExitReason
		{
			Defeated,
			NoOpponents,
			OwnerGone,
			OwnerStopped
		}

		public const string ZdoKeyRecruited = "DE_Recruited";

		public const string ZdoKeyCaste = "DE_Caste";

		public const string ZdoKeyLevel = "DE_Level";

		public const string ZdoKeyXp = "DE_Xp";

		public const string ZdoKeyOwner = "DE_Owner";

		public const string ZdoKeyOwnerName = "DE_OwnerName";

		public const string ZdoKeyName = "DE_Name";

		public const string ZdoKeyCompanionId = "DE_CompanionId";

		public const string ZdoKeyDuel = "DE_Duel";

		public const string ZdoKeyPartyDuel = "DE_PartyDuel";

		public const float SubdueFloorHealthFraction = 0.05f;

		private const float DuelWinXpBonus = 50f;

		private const float DuelDetectRange = 30f;

		private const float OwnerVisionRange = 40f;

		private const float DuelWaitTimeout = 60f;

		private const float DuelScanInterval = 1f;

		private const float StandbyAlertRange = 0f;

		private const float HostileDuration = 30f;

		public const int MaxLevel = 10;

		private static readonly int[] XpToNextByLevel = new int[9] { 100, 250, 450, 700, 1000, 1400, 1900, 2500, 3200 };

		private const float GuardAlertRangeMultiplier = 2.5f;

		private const float SpeedBonusPerLevel = 0.03f;

		private const float HealthBonusPerLevel = 0.04f;

		private Character _character;

		private ZNetView _znv;

		private MonsterAI _ai;

		private float _baseAlertRange;

		private bool _baseAlertRangeCaptured;

		private float _baseRunSpeed;

		private float _baseSpeed;

		private float _baseWalkSpeed;

		private bool _baseSpeedsCaptured;

		private string _customName;

		private string _companionId;

		private long _ownerId;

		private string _ownerName;

		private readonly Dictionary<Character, float> _hostileUntil = new Dictionary<Character, float>();

		private float _pruneTimer;

		private bool _duelEngaged;

		private float _duelWaitTimer;

		private float _duelScanTimer;

		private bool _duelResolved;

		public string DuelOpponentId;

		public long DuelOpponentOwner;

		private bool _partyEngaged;

		private float _partyWaitTimer;

		private float _partyScanTimer;

		private int _partyPeakEnemies;

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

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

		private long _partyOpponentOwner;

		private string _partyOpponentOwnerName;

		private static readonly Dictionary<string, float> s_partyReportLatch = new Dictionary<string, float>();

		private const float PartyReportWindow = 15f;

		private bool _feral;

		private bool _duelModeLocal;

		private bool _partyDuelLocal;

		private static readonly HashSet<DvergrCompanion> s_all = new HashSet<DvergrCompanion>();

		private bool _encumbranceActive;

		public DvergrCaste Caste { get; private set; }

		public int Level { get; private set; } = 1;

		public float Xp { get; private set; }

		public CompanionStance Stance { get; private set; }

		public float XpPercentToNextLevel
		{
			get
			{
				if (!IsMaxLevel)
				{
					return Mathf.Clamp(Xp / XpRequiredForNextLevel() * 100f, 0f, 100f);
				}
				return 100f;
			}
		}

		public bool IsMaxLevel => Level >= 10;

		public bool IsDuelResolved => _duelResolved;

		public long OwnerId => _ownerId;

		public bool DuelMode
		{
			get
			{
				if ((Object)(object)_znv != (Object)null && _znv.IsValid())
				{
					return _znv.GetZDO().GetBool("DE_Duel", false);
				}
				return _duelModeLocal;
			}
			private set
			{
				_duelModeLocal = value;
				if ((Object)(object)_znv != (Object)null && _znv.IsValid())
				{
					_znv.ClaimOwnership();
					_znv.GetZDO().Set("DE_Duel", value);
				}
			}
		}

		public bool PartyDuelMode
		{
			get
			{
				if ((Object)(object)_znv != (Object)null && _znv.IsValid())
				{
					return _znv.GetZDO().GetBool("DE_PartyDuel", false);
				}
				return _partyDuelLocal;
			}
			private set
			{
				_partyDuelLocal = value;
				if ((Object)(object)_znv != (Object)null && _znv.IsValid())
				{
					_znv.ClaimOwnership();
					_znv.GetZDO().Set("DE_PartyDuel", value);
				}
			}
		}

		public bool InAnyDuelMode
		{
			get
			{
				if (!DuelMode)
				{
					return PartyDuelMode;
				}
				return true;
			}
		}

		public string OwnerName
		{
			get
			{
				if (!string.IsNullOrEmpty(_ownerName))
				{
					return _ownerName;
				}
				if (_ownerId != 0L)
				{
					Player player = Player.GetPlayer(_ownerId);
					if ((Object)(object)player != (Object)null)
					{
						return player.GetPlayerName();
					}
				}
				return null;
			}
		}

		public static IEnumerable<DvergrCompanion> All => s_all;

		public bool ChoreActive { get; set; }

		public bool IsEncumbered { get; set; }

		public bool IsFed { get; set; }

		public Sprite FedIcon { get; set; }

		public bool HasCustomName => !string.IsNullOrEmpty(_customName);

		public string DisplayName
		{
			get
			{
				if (!HasCustomName)
				{
					return DefaultName();
				}
				return _customName;
			}
		}

		public string CompanionId
		{
			get
			{
				if (!string.IsNullOrEmpty(_companionId))
				{
					return _companionId;
				}
				if ((Object)(object)_znv != (Object)null && _znv.IsValid())
				{
					string text = _znv.GetZDO().GetString("DE_CompanionId", (string)null);
					if (!string.IsNullOrEmpty(text))
					{
						_companionId = text;
					}
				}
				return _companionId;
			}
		}

		public bool IsFeral => _feral;

		private float XpRequiredForNextLevel()
		{
			int num = Level - 1;
			if (num < 0 || num >= XpToNextByLevel.Length)
			{
				return float.MaxValue;
			}
			return XpToNextByLevel[num];
		}

		public bool MatchesDuelAssignment(DvergrCompanion other)
		{
			if ((Object)(object)other == (Object)null)
			{
				return false;
			}
			if (!string.IsNullOrEmpty(DuelOpponentId))
			{
				return other.CompanionId == DuelOpponentId;
			}
			if (DuelOpponentOwner != 0L)
			{
				return other.OwnerId == DuelOpponentOwner;
			}
			return true;
		}

		public void DespawnToTotem()
		{
			ZNetView component = ((Component)this).GetComponent<ZNetView>();
			if ((Object)(object)component != (Object)null && component.IsValid())
			{
				component.ClaimOwnership();
				ZNetScene.instance.Destroy(((Component)this).gameObject);
			}
			else
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}

		private void OnEnable()
		{
			s_all.Add(this);
		}

		private void OnDisable()
		{
			s_all.Remove(this);
		}

		public static bool PlayerHasCompanion(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			foreach (DvergrCompanion item in s_all)
			{
				if ((Object)(object)item != (Object)null && item.IsOwner(player))
				{
					return true;
				}
			}
			return false;
		}

		private void Awake()
		{
			_character = ((Component)this).GetComponent<Character>();
			_znv = ((Component)this).GetComponent<ZNetView>();
			_ai = ((Component)this).GetComponent<MonsterAI>();
			if ((Object)(object)_znv != (Object)null && _znv.IsValid() && _znv.GetZDO().GetBool("DE_Recruited", false))
			{
				Caste = (DvergrCaste)_znv.GetZDO().GetInt("DE_Caste", 0);
				Level = _znv.GetZDO().GetInt("DE_Level", 1);
				Xp = _znv.GetZDO().GetFloat("DE_Xp", 0f);
				_ownerId = _znv.GetZDO().GetLong("DE_Owner", 0L);
				_ownerName = _znv.GetZDO().GetString("DE_OwnerName", (string)null);
				_customName = _znv.GetZDO().GetString("DE_Name", (string)null);
				_companionId = _znv.GetZDO().GetString("DE_CompanionId", (string)null);
				ApplyLevelToCharacter();
				if (_znv.IsOwner())
				{
					_znv.GetZDO().Set("DE_Duel", false);
					_znv.GetZDO().Set("DE_PartyDuel", false);
				}
			}
			if ((Object)(object)_ai != (Object)null)
			{
				_baseAlertRange = _ai.m_alertRange;
				_baseAlertRangeCaptured = true;
			}
			ApplyMovementTweaks();
		}

		private void ApplyMovementTweaks()
		{
			if ((Object)(object)_ai != (Object)null && ((BaseAI)_ai).m_jumpInterval <= 0f)
			{
				((BaseAI)_ai).m_jumpInterval = 8f;
			}
			if ((Object)(object)_character != (Object)null)
			{
				Character character = _character;
				character.m_jumpForce *= 0.5f;
			}
		}

		public void SetPassive(bool passive)
		{
			if (!((Object)(object)_ai == (Object)null))
			{
				_ai.m_alertRange = (passive ? 0f : (_baseAlertRangeCaptured ? _baseAlertRange : _ai.m_alertRange));
			}
		}

		public void ApplyEncumbrance(bool encumbered)
		{
			IsEncumbered = encumbered;
			if ((Object)(object)_ai == (Object)null)
			{
				return;
			}
			if (encumbered)
			{
				if (!_baseAlertRangeCaptured)
				{
					_baseAlertRange = _ai.m_alertRange;
					_baseAlertRangeCaptured = true;
				}
				_ai.SetTarget((Character)null);
				((BaseAI)_ai).SetAlerted(false);
				_ai.m_alertRange = 0f;
				_encumbranceActive = true;
			}
			else if (_encumbranceActive)
			{
				_encumbranceActive = false;
				if (ChoreActive)
				{
					SetPassive(passive: true);
				}
				else
				{
					RestoreAlertRangeForStance();
				}
			}
		}

		private string DefaultName()
		{
			if ((Object)(object)_character != (Object)null && !string.IsNullOrEmpty(_character.m_name) && Localization.instance != null)
			{
				return Localization.instance.Localize(_character.m_name);
			}
			return "Dvergr";
		}

		public void SetName(string name)
		{
			_customName = (string.IsNullOrWhiteSpace(name) ? null : name.Trim());
			if ((Object)(object)_znv != (Object)null && _znv.IsValid())
			{
				_znv.GetZDO().Set("DE_Name", _customName ?? string.Empty);
			}
		}

		public string GetText()
		{
			return DisplayName;
		}

		public void SetText(string text)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			SetName(text);
			if ((Object)(object)Chat.instance != (Object)null)
			{
				Chat.instance.SetNpcText(((Component)this).gameObject, Vector3.up * 2.2f, 20f, 4f, string.Empty, "I'll answer to " + DisplayName + " now.", false);
			}
		}

		public string EnsureCompanionId()
		{
			string companionId = CompanionId;
			if (!string.IsNullOrEmpty(companionId))
			{
				return companionId;
			}
			_companionId = Guid.NewGuid().ToString("N");
			if ((Object)(object)_znv != (Object)null && _znv.IsValid())
			{
				_znv.GetZDO().Set("DE_CompanionId", _companionId);
			}
			return _companionId;
		}

		public void SetCompanionId(string id)
		{
			if (!string.IsNullOrEmpty(id))
			{
				_companionId = id;
				if ((Object)(object)_znv != (Object)null && _znv.IsValid())
				{
					_znv.GetZDO().Set("DE_CompanionId", id);
				}
			}
		}

		public void SetOwner(long ownerId)
		{
			_ownerId = ownerId;
			if ((Object)(object)_znv != (Object)null && _znv.IsValid())
			{
				_znv.GetZDO().Set("DE_Owner", ownerId);
			}
		}

		public void SetOwnerName(string ownerName)
		{
			_ownerName = (string.IsNullOrWhiteSpace(ownerName) ? null : ownerName);
			if ((Object)(object)_znv != (Object)null && _znv.IsValid())
			{
				_znv.GetZDO().Set("DE_OwnerName", _ownerName ?? string.Empty);
			}
		}

		public bool IsOwner(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			if (_ownerId == 0L)
			{
				return true;
			}
			return player.GetPlayerID() == _ownerId;
		}

		public Player OwnerPlayer()
		{
			if (_ownerId == 0L)
			{
				return Player.m_localPlayer;
			}
			return Player.GetPlayer(_ownerId);
		}

		public bool IsOwnerNear(float range)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			Player val = OwnerPlayer();
			if ((Object)(object)val != (Object)null)
			{
				return Vector3.Distance(((Component)val).transform.position, ((Component)this).transform.position) <= range;
			}
			return false;
		}

		public bool IsHostileTo(Character other)
		{
			if ((Object)(object)other == (Object)null)
			{
				return false;
			}
			Player val = (Player)(object)((other is Player) ? other : null);
			if (val != null)
			{
				if (_feral)
				{
					return true;
				}
				if (IsOwner(val))
				{
					return false;
				}
				if (Stance == CompanionStance.Guard && _ownerId != 0L)
				{
					return true;
				}
			}
			if (_hostileUntil.TryGetValue(other, out var value))
			{
				return Time.time < value;
			}
			return false;
		}

		public void GoFeral(Character attacker)
		{
			if (_feral)
			{
				return;
			}
			_feral = true;
			if (DuelMode)
			{
				ExitDuelMode(DuelExitReason.OwnerStopped);
			}
			if (PartyDuelMode)
			{
				ExitPartyDuelMode(DuelExitReason.OwnerStopped);
			}
			if ((Object)(object)_ai != (Object)null)
			{
				if (!_baseAlertRangeCaptured)
				{
					_baseAlertRange = _ai.m_alertRange;
					_baseAlertRangeCaptured = true;
				}
				_ai.m_alertRange = _baseAlertRange * 2.5f;
				if ((Object)(object)attacker != (Object)null)
				{
					_ai.SetTarget(attacker);
				}
				((BaseAI)_ai).SetAlerted(true);
			}
			Announce(DisplayName + " turns on you, eyes wild with the old corruption!");
		}

		public void MarkHostile(Character player)
		{
			if (!((Object)(object)player == (Object)null))
			{
				_hostileUntil[player] = Time.time + 30f;
			}
		}

		public void Retaliate(Character attacker)
		{
			MarkHostile(attacker);
			if ((Object)(object)_ai != (Object)null)
			{
				_ai.SetTarget(attacker);
				((BaseAI)_ai).SetAlerted(true);
			}
		}

		public void MarkOwnersCompanionsHostile(long ownerId)
		{
			if (ownerId == 0L)
			{
				return;
			}
			foreach (DvergrCompanion item in s_all)
			{
				if (!((Object)(object)item == (Object)null) && !((Object)(object)item == (Object)(object)this) && item._ownerId == ownerId)
				{
					if ((Object)(object)item._character != (Object)null)
					{
						MarkHostile(item._character);
					}
					if ((Object)(object)_character != (Object)null)
					{
						item.MarkHostile(_character);
					}
				}
			}
		}

		public bool HasPotentialDuelRivalNearby()
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			if (_ownerId == 0L)
			{
				return false;
			}
			foreach (DvergrCompanion item in s_all)
			{
				if (!((Object)(object)item == (Object)null) && !((Object)(object)item == (Object)(object)this) && item._ownerId != 0L && item._ownerId != _ownerId)
				{
					Character character = item._character;
					if (!((Object)(object)character == (Object)null) && !character.IsDead() && Vector3.Distance(((Component)this).transform.position, ((Component)item).transform.position) <= 30f)
					{
						return true;
					}
				}
			}
			return false;
		}

		private void Update()
		{
			if (!InAnyDuelMode && (Stance == CompanionStance.Standby || ChoreActive) && (Object)(object)_ai != (Object)null)
			{
				Character targetCreature = ((BaseAI)_ai).GetTargetCreature();
				if ((Object)(object)targetCreature != (Object)null)
				{
					Player val = (Player)(object)((targetCreature is Player) ? targetCreature : null);
					if (val == null || !IsHostileTo((Character)(object)val))
					{
						_ai.SetTarget((Character)null);
					}
				}
			}
			bool flag = (Object)(object)_znv == (Object)null || !_znv.IsValid() || _znv.IsOwner();
			if (DuelMode && flag)
			{
				TickDuel();
			}
			else if (PartyDuelMode && flag)
			{
				TickPartyDuel();
			}
			_pruneTimer += Time.deltaTime;
			if (!(_pruneTimer >= 5f))
			{
				return;
			}
			_pruneTimer = 0f;
			if (_hostileUntil.Count <= 0)
			{
				return;
			}
			float time = Time.time;
			List<Character> list = new List<Character>();
			foreach (KeyValuePair<Character, float> item in _hostileUntil)
			{
				if (item.Value <= time)
				{
					list.Add(item.Key);
				}
			}
			foreach (Character item2 in list)
			{
				_hostileUntil.Remove(item2);
			}
		}

		public void SetCaste(DvergrCaste caste)
		{
			Caste = caste;
			if ((Object)(object)_znv != (Object)null && _znv.IsValid())
			{
				_znv.GetZDO().Set("DE_Caste", (int)caste);
			}
		}

		public void AddXp(float amount)
		{
			if (!(amount <= 0f) && Level < 10)
			{
				Xp += amount;
				while (Level < 10 && Xp >= XpRequiredForNextLevel())
				{
					Xp -= XpRequiredForNextLevel();
					Level++;
					ApplyLevelToCharacter();
					Plugin.Log.LogInfo((object)$"Dvergr {Caste} reached level {Level}.");
					ServerGuideBridge.RaiseLevelUp(Caste, Level);
				}
				if (Level >= 10)
				{
					Xp = 0f;
				}
				Persist();
			}
		}

		private void ApplyLevelToCharacter()
		{
			if (!((Object)(object)_character == (Object)null))
			{
				_character.SetLevel(Level);
				ApplyCasteBonus();
			}
		}

		private void ApplyCasteBonus()
		{
			int num = Level - 1;
			switch (Caste)
			{
			case DvergrCaste.Rogue:
			case DvergrCaste.FireMage:
			{
				if (!_baseSpeedsCaptured)
				{
					_baseRunSpeed = _character.m_runSpeed;
					_baseSpeed = _character.m_speed;
					_baseWalkSpeed = _character.m_walkSpeed;
					_baseSpeedsCaptured = true;
				}
				float num3 = 1f + 0.03f * (float)num;
				_character.m_runSpeed = _baseRunSpeed * num3;
				_character.m_speed = _baseSpeed * num3;
				_character.m_walkSpeed = _baseWalkSpeed * num3;
				break;
			}
			case DvergrCaste.IceMage:
			case DvergrCaste.SupportMage:
			{
				float maxHealth = _character.GetMaxHealth();
				float num2 = maxHealth * (1f + 0.04f * (float)num);
				_character.SetMaxHealth(num2);
				_character.SetHealth(Mathf.Min(_character.GetHealth() + (num2 - maxHealth), num2));
				break;
			}
			}
		}

		private void Persist()
		{
			if ((Object)(object)_znv != (Object)null && _znv.IsValid())
			{
				_znv.GetZDO().Set("DE_Level", Level);
				_znv.GetZDO().Set("DE_Xp", Xp);
			}
		}

		public void SetStance(CompanionStance stance, GameObject followTarget)
		{
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			Stance = stance;
			AnnounceCapability();
			if (!((Object)(object)_ai == (Object)null))
			{
				if (!_baseAlertRangeCaptured)
				{
					_baseAlertRange = _ai.m_alertRange;
					_baseAlertRangeCaptured = true;
				}
				switch (stance)
				{
				case CompanionStance.Follow:
					_ai.m_alertRange = _baseAlertRange;
					_ai.SetFollowTarget(followTarget);
					break;
				case CompanionStance.Guard:
					_ai.m_alertRange = _baseAlertRange * 2.5f;
					_ai.SetFollowTarget((GameObject)null);
					((BaseAI)_ai).SetPatrolPoint(((Component)this).transform.position);
					break;
				case CompanionStance.Standby:
					_ai.m_alertRange = 0f;
					_ai.SetFollowTarget((GameObject)null);
					((BaseAI)_ai).SetPatrolPoint(((Component)this).transform.position);
					_ai.SetTarget((Character)null);
					break;
				}
			}
		}

		public void AnnounceCapability()
		{
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Chat.instance == (Object)null) && !((Object)(object)_character == (Object)null))
			{
				string text = Caste switch
				{
					DvergrCaste.FireMage => "tend smelters, kilns and forges", 
					DvergrCaste.IceMage => "run the refineries", 
					DvergrCaste.SupportMage => "farm, cook, brew and tend the beasts", 
					_ => "haul loose drops to a chest", 
				};
				string text2 = Stance switch
				{
					CompanionStance.Guard => "I'll hold this ground. Or set me to " + text + ".", 
					CompanionStance.Standby => "I'll wait here, quietly. Set me to " + text + " when you're ready.", 
					_ => "I'll follow and fight at your side. Set me to " + text + ".", 
				};
				Chat.instance.SetNpcText(((Component)this).gameObject, Vector3.up * 2.2f, 20f, 6f, string.Empty, text2, false);
			}
		}

		public void AnnounceBoarded()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Chat.instance == (Object)null) && !((Object)(object)_character == (Object)null))
			{
				Chat.instance.SetNpcText(((Component)this).gameObject, Vector3.up * 2.2f, 20f, 5f, string.Empty, "Aboard — I'll take a seat and hold fast.", false);
			}
		}

		public bool EnterDuelMode()
		{
			if (DuelMode)
			{
				return true;
			}
			if (ChoreActive || _feral || PartyDuelMode)
			{
				return false;
			}
			DuelMode = true;
			_duelEngaged = false;
			_duelResolved = false;
			_duelWaitTimer = 0f;
			_duelScanTimer = 0f;
			if ((Object)(object)_ai != (Object)null)
			{
				if (!_baseAlertRangeCaptured)
				{
					_baseAlertRange = _ai.m_alertRange;
					_baseAlertRangeCaptured = true;
				}
				_ai.m_alertRange = 30f;
				((BaseAI)_ai).SetAlerted(true);
			}
			Announce(DisplayName + " squares up — challenging rival companions to a duel.");
			return true;
		}

		public void ExitDuelMode(DuelExitReason reason)
		{
			if (DuelMode)
			{
				DuelMode = false;
				_duelEngaged = false;
				DuelOpponentId = null;
				DuelOpponentOwner = 0L;
				if ((Object)(object)_ai != (Object)null)
				{
					_ai.SetTarget((Character)null);
					((BaseAI)_ai).SetAlerted(false);
					RestoreAlertRangeForStance();
				}
				switch (reason)
				{
				case DuelExitReason.Defeated:
					Announce(DisplayName + " is subdued and yields the duel.");
					break;
				case DuelExitReason.NoOpponents:
					Announce(DisplayName + " finds no more challengers and stands down.");
					break;
				case DuelExitReason.OwnerGone:
					Announce(DisplayName + " loses sight of its owner and breaks off the duel.");
					break;
				case DuelExitReason.OwnerStopped:
					Announce(DisplayName + " lowers its guard and leaves the sparring circle.");
					break;
				}
			}
		}

		public bool ResolveSubdue(DvergrCompanion winner)
		{
			if (_duelResolved)
			{
				return false;
			}
			_duelResolved = true;
			winner?.AwardDuelWin(this);
			ExitDuelMode(DuelExitReason.Defeated);
			return true;
		}

		public void AwardDuelWin(DvergrCompanion loser)
		{
			AddXp(50f);
			ServerGuideBridge.RaiseDuelWon(Caste, ((Object)(object)loser != (Object)null) ? loser.Caste : Caste, DisplayName, ((Object)(object)loser != (Object)null) ? loser.DisplayName : null);
			if ((Object)(object)loser != (Object)null && _ownerId != 0L && loser._ownerId != 0L && _ownerId != loser._ownerId)
			{
				string text = EnsureCompanionId();
				string companionId = loser.CompanionId;
				if (!string.IsNullOrEmpty(text) && !string.IsNullOrEmpty(companionId))
				{
					LeaderboardSync.ReportDuel(new DuelResult
					{
						WinnerId = text,
						WinnerOwnerId = _ownerId,
						WinnerOwnerName = (OwnerName ?? string.Empty),
						WinnerName = DisplayName,
						WinnerCaste = (int)Caste,
						LoserId = companionId,
						LoserOwnerId = loser._ownerId,
						LoserOwnerName = (loser.OwnerName ?? string.Empty),
						LoserName = loser.DisplayName,
						LoserCaste = (int)loser.Caste
					});
				}
			}
			Announce($"{DisplayName} wins the bout! (+{50f:0} XP)");
			if ((Object)(object)Chat.instance != (Object)null)
			{
				string ownerName = OwnerName;
				string text2 = (((Object)(object)loser != (Object)null) ? loser.DisplayName : "its rival");
				string text3 = (string.IsNullOrEmpty(ownerName) ? DisplayName : (DisplayName + " (" + ownerName + ")"));
				Chat.instance.SendText((Type)2, text3 + " wins the duel against " + text2 + "!");
			}
		}

		private void TickDuel()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			Player val = OwnerPlayer();
			if ((Object)(object)val == (Object)null || Vector3.Distance(((Component)val).transform.position, ((Component)this).transform.position) > 40f)
			{
				ExitDuelMode(DuelExitReason.OwnerGone);
				return;
			}
			_duelScanTimer += Time.deltaTime;
			if (_duelScanTimer < 1f)
			{
				return;
			}
			_duelScanTimer = 0f;
			DvergrCompanion dvergrCompanion = FindNearestDuelRival();
			if ((Object)(object)dvergrCompanion != (Object)null)
			{
				_duelEngaged = true;
				_duelWaitTimer = 0f;
				if ((Object)(object)_ai != (Object)null)
				{
					Character targetCreature = ((BaseAI)_ai).GetTargetCreature();
					if ((Object)(object)targetCreature == (Object)null || targetCreature.IsDead() || (Object)(object)((Component)targetCreature).GetComponent<DvergrCompanion>() != (Object)(object)dvergrCompanion)
					{
						_ai.SetTarget(((Component)dvergrCompanion).GetComponent<Character>());
						((BaseAI)_ai).SetAlerted(true);
					}
				}
			}
			else if (_duelEngaged)
			{
				ExitDuelMode(DuelExitReason.NoOpponents);
			}
			else
			{
				_duelWaitTimer += 1f;
				if (_duelWaitTimer >= 60f)
				{
					ExitDuelMode(DuelExitReason.NoOpponents);
				}
			}
		}

		private DvergrCompanion FindNearestDuelRival()
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			DvergrCompanion result = null;
			float num = float.MaxValue;
			foreach (DvergrCompanion item in s_all)
			{
				if ((Object)(object)item == (Object)null || (Object)(object)item == (Object)(object)this || !item.DuelMode || item._ownerId == _ownerId || _ownerId == 0L || item._ownerId == 0L)
				{
					continue;
				}
				Character character = item._character;
				if (!((Object)(object)character == (Object)null) && !character.IsDead())
				{
					float num2 = Vector3.Distance(((Component)this).transform.position, ((Component)item).transform.position);
					if (num2 <= 30f && num2 < num)
					{
						num = num2;
						result = item;
					}
				}
			}
			return result;
		}

		public bool EnterPartyDuelMode()
		{
			if (PartyDuelMode)
			{
				return true;
			}
			if (ChoreActive || _feral || DuelMode)
			{
				return false;
			}
			PartyDuelMode = true;
			_duelResolved = false;
			_partyEngaged = false;
			_partyWaitTimer = 0f;
			_partyScanTimer = 0f;
			_partyPeakEnemies = 0;
			_partyAllySnap.Clear();
			_partyEnemySnap.Clear();
			_partyOpponentOwner = 0L;
			_partyOpponentOwnerName = null;
			if ((Object)(object)_ai != (Object)null)
			{
				if (!_baseAlertRangeCaptured)
				{
					_baseAlertRange = _ai.m_alertRange;
					_baseAlertRangeCaptured = true;
				}
				_ai.m_alertRange = 30f;
				((BaseAI)_ai).SetAlerted(true);
			}
			Announce(DisplayName + " joins the melee — a party duel!");
			return true;
		}

		public void ExitPartyDuelMode(DuelExitReason reason)
		{
			if (PartyDuelMode)
			{
				PartyDuelMode = false;
				_partyEngaged = false;
				DuelOpponentId = null;
				DuelOpponentOwner = 0L;
				if ((Object)(object)_ai != (Object)null)
				{
					_ai.SetTarget((Character)null);
					((BaseAI)_ai).SetAlerted(false);
					RestoreAlertRangeForStance();
				}
				switch (reason)
				{
				case DuelExitReason.Defeated:
					Announce(DisplayName + " is subdued and steps out of the melee.");
					break;
				case DuelExitReason.NoOpponents:
					Announce(DisplayName + "'s side stands victorious!");
					break;
				case DuelExitReason.OwnerGone:
					Announce(DisplayName + " loses sight of its owner and withdraws.");
					break;
				case DuelExitReason.OwnerStopped:
					Announce(DisplayName + " lowers its guard and leaves the melee.");
					break;
				}
			}
		}

		public bool ResolvePartySubdue()
		{
			if (_duelResolved)
			{
				return false;
			}
			_duelResolved = true;
			ExitPartyDuelMode(DuelExitReason.Defeated);
			return true;
		}

		private void TickPartyDuel()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			Player val = OwnerPlayer();
			if ((Object)(object)val == (Object)null || Vector3.Distance(((Component)val).transform.position, ((Component)this).transform.position) > 40f)
			{
				ExitPartyDuelMode(DuelExitReason.OwnerGone);
				return;
			}
			_partyScanTimer += Time.deltaTime;
			if (_partyScanTimer < 1f)
			{
				return;
			}
			_partyScanTimer = 0f;
			int num = ScanParty();
			if (num > _partyPeakEnemies)
			{
				_partyPeakEnemies = num;
			}
			if (num > 0)
			{
				_partyEngaged = true;
				_partyWaitTimer = 0f;
				if (!((Object)(object)_ai != (Object)null))
				{
					return;
				}
				Character targetCreature = ((BaseAI)_ai).GetTargetCreature();
				if ((Object)(object)targetCreature == (Object)null || targetCreature.IsDead() || (Object)(object)((Component)targetCreature).GetComponent<DvergrCompanion>() == (Object)null || !((Component)targetCreature).GetComponent<DvergrCompanion>().PartyDuelMode)
				{
					DvergrCompanion dvergrCompanion = FindNearestPartyRival();
					if ((Object)(object)dvergrCompanion != (Object)null)
					{
						_ai.SetTarget(((Component)dvergrCompanion).GetComponent<Character>());
						((BaseAI)_ai).SetAlerted(true);
					}
				}
			}
			else if (_partyEngaged)
			{
				AwardPartyWin();
				ExitPartyDuelMode(DuelExitReason.NoOpponents);
			}
			else
			{
				_partyWaitTimer += 1f;
				if (_partyWaitTimer >= 60f)
				{
					ExitPartyDuelMode(DuelExitReason.NoOpponents);
				}
			}
		}

		private void AwardPartyWin()
		{
			int num = Mathf.Max(1, _partyAllySnap.Count);
			int num2 = Mathf.Max(1, (_partyEnemySnap.Count > 0) ? _partyEnemySnap.Count : _partyPeakEnemies);
			float num3 = 50f * (float)num2 / (float)num;
			AddXp(num3);
			Announce($"{DisplayName} wins the party duel! (+{num3:0} XP)");
			if (_partyOpponentOwner != 0L && _ownerId != 0L)
			{
				string key = ((_ownerId <= _partyOpponentOwner) ? $"{_ownerId}|{_partyOpponentOwner}" : $"{_partyOpponentOwner}|{_ownerId}");
				if (!s_partyReportLatch.TryGetValue(key, out var value) || !(Time.time - value < 15f))
				{
					s_partyReportLatch[key] = Time.time;
					string text = LeaderboardStore.FindParty(_ownerId)?.partyName;
					LeaderboardSync.ReportPartyDuel(new PartyDuelResult
					{
						WinnerOwnerId = _ownerId,
						WinnerOwnerName = (OwnerName ?? string.Empty),
						LoserOwnerId = _partyOpponentOwner,
						LoserOwnerName = (_partyOpponentOwnerName ?? string.Empty),
						MvpCaste = (int)Caste,
						WinnerMembers = SnapToList(_partyAllySnap),
						LoserMembers = SnapToList(_partyEnemySnap),
						WinnerPartyName = (text ?? string.Empty)
					});
					ServerGuideBridge.RaisePartyDuelWon(OwnerName ?? string.Empty, num, _partyOpponentOwnerName ?? string.Empty, (int)Caste, text);
				}
			}
		}

		private static List<PartyMemberSnap> SnapToList(Dictionary<string, string> snap)
		{
			List<PartyMemberSnap> list = new List<PartyMemberSnap>(snap.Count);
			foreach (KeyValuePair<string, string> item in snap)
			{
				string[] array = item.Value.Split(new char[1] { ':' });
				int result = 0;
				int result2 = 1;
				if (array.Length >= 2)
				{
					int.TryParse(array[0], out result);
					int.TryParse(array[1], out result2);
				}
				list.Add(new PartyMemberSnap
				{
					companionId = item.Key,
					caste = result,
					level = result2
				});
			}
			return list;
		}

		private int ScanParty()
		{
			string companionId = CompanionId;
			if (!string.IsNullOrEmpty(companionId))
			{
				_partyAllySnap[companionId] = $"{(int)Caste}:{Level}";
			}
			int num = 0;
			foreach (DvergrCompanion item in s_all)
			{
				if ((Object)(object)item == (Object)null || (Object)(object)item == (Object)(object)this || !item.PartyDuelMode || _ownerId == 0L || item._ownerId == 0L)
				{
					continue;
				}
				Character character = item._character;
				if ((Object)(object)character == (Object)null || character.IsDead())
				{
					continue;
				}
				string companionId2 = item.CompanionId;
				if (item._ownerId == _ownerId)
				{
					if (!string.IsNullOrEmpty(companionId2))
					{
						_partyAllySnap[companionId2] = $"{(int)item.Caste}:{item.Level}";
					}
					continue;
				}
				num++;
				if (!string.IsNullOrEmpty(companionId2))
				{
					_partyEnemySnap[companionId2] = $"{(int)item.Caste}:{item.Level}";
				}
				if (_partyOpponentOwner == 0L)
				{
					_partyOpponentOwner = item._ownerId;
					_partyOpponentOwnerName = item.OwnerName;
				}
			}
			return num;
		}

		private DvergrCompanion FindNearestPartyRival()
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			DvergrCompanion result = null;
			float num = float.MaxValue;
			foreach (DvergrCompanion item in s_all)
			{
				if ((Object)(object)item == (Object)null || (Object)(object)item == (Object)(object)this || !item.PartyDuelMode || item._ownerId == _ownerId || _ownerId == 0L || item._ownerId == 0L)
				{
					continue;
				}
				Character character = item._character;
				if (!((Object)(object)character == (Object)null) && !character.IsDead())
				{
					float num2 = Vector3.Distance(((Component)this).transform.position, ((Component)item).transform.position);
					if (num2 < num)
					{
						num = num2;
						result = item;
					}
				}
			}
			return result;
		}

		public bool HasPotentialPartyRivalNearby()
		{
			return HasPotentialDuelRivalNearby();
		}

		private void RestoreAlertRangeForStance()
		{
			if (!((Object)(object)_ai == (Object)null))
			{
				float num = (_baseAlertRangeCaptured ? _baseAlertRange : _ai.m_alertRange);
				switch (Stance)
				{
				case CompanionStance.Guard:
					_ai.m_alertRange = num * 2.5f;
					break;
				case CompanionStance.Standby:
					_ai.m_alertRange = 0f;
					break;
				default:
					_ai.m_alertRange = num;
					break;
				}
			}
		}

		private void Announce(string line)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_character == (Object)null))
			{
				if ((Object)(object)Chat.instance != (Object)null)
				{
					Chat.instance.SetNpcText(((Component)this).gameObject, Vector3.up * 2.2f, 20f, 5f, string.Empty, line, false);
				}
				if ((Object)(object)MessageHud.instance != (Object)null && (Object)(object)Player.m_localPlayer != (Object)null && IsOwner(Player.m_localPlayer))
				{
					MessageHud.instance.ShowMessage((MessageType)2, line, 0, (Sprite)null, false);
				}
			}
		}
	}
	public enum CompanionStance
	{
		Follow,
		Guard,
		Standby
	}
	[HarmonyPatch(typeof(InventoryGui), "Show")]
	public static class InventoryMenuBar
	{
		private struct MenuEntry
		{
			public string Name;

			public string Label;

			public Action Open;
		}

		private const float TopEdgeInset = -18f;

		private const float ButtonWidth = 132f;

		private const float ButtonHeight = 32f;

		private const float ButtonGap = 6f;

		private static MenuEntry[] Entries => new MenuEntry[3]
		{
			new MenuEntry
			{
				Name = "LSII_RankingsButton",
				Label = "Rankings",
				Open = delegate
				{
					RankingBoard.Open();
				}
			},
			new MenuEntry
			{
				Name = "LSII_TournamentButton",
				Label = "Tournaments",
				Open = delegate
				{
					TournamentRegistration.Toggle(Player.m_localPlayer);
				}
			},
			new MenuEntry
			{
				Name = "LSII_BountyBoardButton",
				Label = "Bounty Board",
				Open = delegate
				{
					BountyBoardPanel.Toggle(Player.m_localPlayer);
				}
			}
		};

		public static void Postfix(InventoryGui __instance)
		{
			try
			{
				Ensure(__instance);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[ui] inventory menu bar failed: " + ex.Message));
			}
		}

		private static void Ensure(InventoryGui gui)
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)gui == (Object)null || (Object)(object)gui.m_player == (Object)null)
			{
				return;
			}
			Button takeAllButton = gui.m_takeAllButton;
			if ((Object)(object)takeAllButton == (Object)null)
			{
				return;
			}
			Transform parent = ((Transform)gui.m_player).parent;
			RectTransform val = (RectTransform)(((object)((parent is RectTransform) ? parent : null)) ?? ((object)gui.m_player));
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			MenuEntry[] entries = Entries;
			float num = (float)entries.Length * 132f + (float)(entries.Length - 1) * 6f;
			float num2 = (0f - num) / 2f + 66f;
			Vector2 val2 = ParseOffset(MenuBarOffset());
			bool flag = false;
			for (int i = 0; i < entries.Length; i++)
			{
				MenuEntry entry = entries[i];
				if (!((Object)(object)((Transform)val).Find(entry.Name) != (Object)null))
				{
					float num3 = num2 + (float)i * 138f;
					Build(takeAllButton, val, entry, new Vector2(num3, -18f) + val2);
					flag = true;
				}
			}
			if (flag)
			{
				Plugin.Log.LogInfo((object)($"[ui] inventory menu bar: {entries.Length} button(s) under " + $"'{((Object)val).name}', row width {num}, offset {val2}."));
			}
		}

		private static void Build(Button source, RectTransform parent, MenuEntry entry, Vector2 pos)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Expected O, but got Unknown
			GameObject val = Object.Instantiate<GameObject>(((Component)source).gameObject, (Transform)(object)parent);
			((Object)val).name = entry.Name;
			(val.GetComponent<LayoutElement>() ?? val.AddComponent<LayoutElement>()).ignoreLayout = true;
			RectTransform component = val.GetComponent<RectTransform>();
			if ((Object)(object)component != (Object)null)
			{
				Vector2 val2 = default(Vector2);
				((Vector2)(ref val2))..ctor(0.5f, 1f);
				component.anchorMax = val2;
				component.anchorMin = val2;
				component.pivot = new Vector2(0.5f, 1f);
				component.sizeDelta = new Vector2(132f, 32f);
				((Transform)component).localScale = Vector3.one;
				component.anchoredPosition = pos;
			}
			TMP_Text componentInChildren = val.GetComponentInChildren<TMP_Text>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				componentInChildren.text = entry.Label;
				componentInChildren.enableAutoSizing = false;
				componentInChildren.fontSize = 14f;
			}
			Button component2 = val.GetComponent<Button>();
			if ((Object)(object)component2 != (Object)null)
			{
				Action open = entry.Open;
				((UnityEventBase)component2.onClick).RemoveAllListeners();
				((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
				{
					if ((Object)(object)InventoryGui.instance != (Object)null)
					{
						InventoryGui.instance.Hide();
					}
					open();
				});
				((Selectable)component2).interactable = true;
			}
			val.SetActive(true);
		}

		private static string MenuBarOffset()
		{
			string text = Plugin.BountyButtonOffset?.Value;
			if (!string.IsNullOrEmpty(text) && text.Replace(" ", "") != "0,0")
			{
				return text;
			}
			return Plugin.MenuBarOffset?.Value;
		}

		private static Vector2 ParseOffset(string s)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(s))
			{
				return Vector2.zero;
			}
			string[] array = s.Split(new char[1] { ',' });
			if (array.Length != 2)
			{
				return Vector2.zero;
			}
			if (!float.TryParse(array[0].Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
			{
				return Vector2.zero;
			}
			if (!float.TryParse(array[1].Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out var result2))
			{
				return Vector2.zero;
			}
			return new Vector2(result, result2);
		}
	}
	public static class MeadFeedingService
	{
		public static bool TryFeed(Character target, Player player)
		{
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Invalid comparison between Unknown and I4
			Inventory inventory = ((Humanoid)player).GetInventory();
			ItemData val = null;
			float num = 0f;
			foreach (ItemData allItem in inventory.GetAllItems())
			{
				float num2 = HealthMeadRestoreAmount(allItem);
				if (num2 > 0f)
				{
					val = allItem;
					num = num2;
					break;
				}
			}
			if (val == null)
			{
				foreach (ItemData allItem2 in inventory.GetAllItems())
				{
					if (allItem2.m_shared != null && (int)allItem2.m_shared.m_itemType == 2)
					{
						string text = (((Object)(object)allItem2.m_dropPrefab != (Object)null) ? ((Object)allItem2.m_dropPrefab).name : allItem2.m_shared.m_name);
						StatusEffect consumeStatusEffect = allItem2.m_shared.m_consumeStatusEffect;
						Plugin.Log.LogInfo((object)("[feed] Consumable not matched as health mead: '" + text + "' " + string.Format("(m_food={0}, consumeEffect={1}).", allItem2.m_shared.m_food, ((Object)(object)consumeStatusEffect != (Object)null) ? ((object)consumeStatusEffect).GetType().Name : "null")));
					}
				}
				return false;
			}
			inventory.RemoveItem(val, 1);
			float num3 = num;
			target.Heal(num3, true);
			EffectList val2 = (((Object)(object)val.m_shared.m_consumeStatusEffect != (Object)null) ? val.m_shared.m_consumeStatusEffect.m_startEffects : null);
			if (val2 != null)
			{
				val2.Create(((Component)target).transform.position, ((Component)target).transform.rotation, ((Component)target).transform, 1f, -1);
			}
			Plugin.Log.LogInfo((object)($"[feed] Fed companion: potion restores {num} HP " + "to the companion (flat, same as it heals the player)."));
			return true;
		}

		private static float HealthMeadRestoreAmount(ItemData item)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Invalid comparison between Unknown and I4
			if (item?.m_shared == null)
			{
				return 0f;
			}
			if ((int)item.m_shared.m_itemType != 2)
			{
				return 0f;
			}
			StatusEffect consumeStatusEffect = item.m_shared.m_consumeStatusEffect;
			SE_Stats val = (SE_Stats)(object)((consumeStatusEffect is SE_Stats) ? consumeStatusEffect : null);
			if ((Object)(object)val == (Object)null)
			{
				return 0f;
			}
			float num = val.m_healthUpFront + val.m_healthOverTime;
			if (!(num > 0f))
			{
				return 0f;
			}
			return num;
		}
	}
	public static class ModalPanels
	{
		public static bool AnyOpen
		{
			get
			{
				if (!TournamentRegistration.IsOpen)
				{
					return BountyBoardPanel.IsOpen;
				}
				return true;
			}
		}
	}
	public static class PlantingCatalog
	{
		private static Dictionary<string, GameObject> s_map;

		private static void EnsureBuilt()
		{
			if (s_map != null || (Object)(object)ZNetScene.instance == (Object)null)
			{
				return;
			}
			Dictionary<string, GameObject> dictionary = new Dictionary<string, GameObject>();
			foreach (GameObject prefab in ZNetScene.instance.m_prefabs)
			{
				if ((Object)(object)prefab == (Object)null)
				{
					continue;
				}
				Plant component = prefab.GetComponent<Plant>();
				Piece component2 = prefab.GetComponent<Piece>();
				if ((Object)(object)component == (Object)null || (Object)(object)component2 == (Object)null || component2.m_resources == null)
				{
					continue;
				}
				Requirement[] resources = component2.m_resources;
				foreach (Requirement val in resources)
				{
					if (val != null && !((Object)(object)val.m_resItem == (Object)null))
					{
						string name = ((Object)val.m_resItem).name;
						if (!string.IsNullOrEmpty(name) && !dictionary.ContainsKey(name))
						{
							dictionary[name] = prefab;
						}
					}
				}
			}
			s_map = dictionary;
			Plugin.Log.LogInfo((object)$"[farm] planting catalog built: {s_map.Count} seed→sapling entries.");
		}

		public static bool TryGetSapling(string seedPrefabName, out GameObject sapling)
		{
			sapling = null;
			if (string.IsNullOrEmpty(seedPrefabName))
			{
				return false;
			}
			EnsureBuilt();
			if (s_map != null)
			{
				return s_map.TryGetValue(seedPrefabName, out sapling);
			}
			return false;
		}
	}
	public static class RankingBoard
	{
		private const int MaxRows = 12;

		public static void Open()
		{
			if ((Object)(object)TextViewer.instance == (Object)null)
			{
				if ((Object)(object)MessageHud.instance != (Object)null)
				{
					MessageHud.instance.ShowMessage((MessageType)2, "Rankings aren't available right now.", 0, (Sprite)null, false);
				}
			}
			else
			{
				TextViewer.instance.ShowText((Style)0, "Dvergr Rankings", Build(), false);
			}
		}

		private static string Build()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("<align=left>");
			stringBuilder.Append("<size=150%><color=#FFD24A>⚔ Duel Ladder</color></size>\n");
			List<CompanionRecord> list = LeaderboardStore.Ranked();
			if (list.Count == 0)
			{
				stringBuilder.Append("<color=#AAAAAA>No duels recorded yet. Pit your companion against another player's with [J].</color>\n");
			}
			else
			{
				for (int i = 0; i < list.Count && i < 12; i++)
				{
					CompanionRecord companionRecord = list[i];
					string text = (string.IsNullOrEmpty(companionRecord.companionName) ? "?" : companionRecord.companionName);
					string text2 = (string.IsNullOrEmpty(companionRecord.ownerName) ? "?" : companionRecord.ownerName);
					string text3 = ((DvergrCaste)companionRecord.caste).Display();
					stringBuilder.Append($"<color=#FFFFFF>#{i + 1,-2}</color> ").Append($"<color=#8FE3FF>{companionRecord.rating,4}</color>  ").Append(text + " <color=#AAAAAA>(" + text2 + " · " + text3 + ")</color>  ")
						.Append($"<color=#B8F5B0>{companionRecord.wins}W</color>/<color=#F5B0B0>{companionRecord.losses}L</color>\n");
				}
			}
			stringBuilder.Append("\n<size=150%><color=#FFD24A>\ud83d\udee1 Party Ladder</color></size>\n");
			List<PartyRecord> list2 = LeaderboardStore.RankedParties();
			if (list2.Count == 0)
			{
				stringBuilder.Append("<color=#AAAAAA>No party duels recorded yet. Gather a team with [K]; name it with de_party_name.</color>\n");
			}
			else
			{
				for (int j = 0; j < list2.Count && j < 12; j++)
				{
					PartyRecord partyRecord = list2[j];
					string text4 = (string.IsNullOrEmpty(partyRecord.ownerName) ? "?" : partyRecord.ownerName);
					string text5 = (string.IsNullOrEmpty(partyRecord.partyName) ? text4 : (partyRecord.partyName + " <color=#AAAAAA>(" + text4 + ")</color>"));
					int num = ((partyRecord.memberSnapshot != null) ? partyRecord.memberSnapshot.Count : 0);
					stringBuilder.Append($"<color=#FFFFFF>#{j + 1,-2}</color> ").Append($"<color=#8FE3FF>{partyRecord.rating,4}</color>  ").Append(text5 + "  ")
						.Append($"<color=#B8F5B0>{partyRecord.wins}W</color>/<color=#F5B0B0>{partyRecord.losses}L</color>  ")
						.Append($"<color=#AAAAAA>team {num}</color>\n");
				}
			}
			if (BountyFeatureGate.AvailableToLocalPlayer)
			{
				stringBuilder.Append("\n<size=150%><color=#FFD24A>Bounty Hunters</color></size>\n");
				List<BountyHunterRecord> list3 = BountyLeaderboardStore.Ranked();
				if (list3.Count == 0)
				{
					stringBuilder.Append("<color=#AAAAAA>No bounties answered yet.</color>\n");
				}
				else
				{
					for (int k = 0; k < list3.Count && k < 12; k++)
					{
						BountyHunterRecord bountyHunterRecord = list3[k];
						string text6 = (string.IsNullOrEmpty(bountyHunterRecord.ownerName) ? "?" : bountyHunterRecord.ownerName);
						string text7 = ((bountyHunterRecord.bestTier > 0) ? BountyTiers.TierName(bountyHunterRecord.bestTier) : "—");
						stringBuilder.Append($"<color=#FFFFFF>#{k + 1,-2}</color> ").Append($"<color=#8FE3FF>{bountyHunterRecord.points,5}</color>  ").Append(text6 + "  ")
							.Append($"<color=#B8F5B0>{bountyHunterRecord.kills} felled</color>/<color=#8FE3FF>{bountyHunterRecord.communes} freed</color>  ")
							.Append("<color=#AAAAAA>best: " + text7 + "</color>\n");
					}
				}
			}
			stringBuilder.Append("</align>");
			return stringBuilder.ToString();
		}
	}
	public class SealingRite : MonoBehaviour
	{
		public const string ZdoKeySealing = "DE_Sealing";

		public const string StaffPrefab = "StaffSkeleton";

		private const float DamageEpsilon = 0.5f;

		private const float ReleaseGraceSeconds = 0.5f;

		private const float PulseIntervalStart = 1f;

		private const float PulseIntervalEnd = 0.28f;

		private const float BeatInterval = 1.25f;

		private DvergrCompanion _target;

		private Player _player;

		private float _elapsed;

		private float _duration;

		private float _beatTimer;

		private float _pulseTimer;

		private float _releaseGrace;

		private float _lastPlayerHealth;

		private int _beatIndex;

		private static string _staffSharedName;

		private static string _wispSharedName;

		private static readonly string[] BeatLines = new string[3] { "The staff drinks the light from its eyes...", "Bind the soul — do not falter.", "The wisp swells with a borrowed spirit." };

		public static SealingRite Instance { get; private set; }

		public bool IsActive => (Object)(object)_target != (Object)null;

		private void Awake()
		{
			Instance = this;
		}

		public static bool CanSeal(Player player, DvergrCompanion companion, out string reason)
		{
			reason = null;
			if ((Object)(object)player == (Object)null || (Object)(object)companion == (Object)null)
			{
				return false;
			}
			if (Plugin.StaffSealEnabled == null || !Plugin.StaffSealEnabled.Value)
			{
				return false;
			}
			if (!HasStaffEquipped(player))
			{
				return false;
			}
			if (!companion.IsOwner(player))
			{
				reason = "This companion answers to another.";
				return false;
			}
			Character component = ((Component)companion).GetComponent<Character>();
			if ((Object)(object)component == (Object)null || component.IsDead())
			{
				return false;
			}
			if (companion.Stance != CompanionStance.Follow)
			{
				reason = "Only a companion in Follow can be sealed — set it to follow you first.";
				return false;
			}
			if (companion.ChoreActive)
			{
				reason = "Recall it from its work before sealing it.";
				return false;
			}
			if (companion.InAnyDuelMode)
			{
				reason = "It is in a duel — stand it down first.";
				return false;
			}
			if (companion.IsFeral)
			{
				reason = "It has turned on you. The staff finds nothing to bind.";
				return false;
			}
			int num = BloodMagicLevel(player);
			int num2 = Mathf.Max(0, Plugin.SealMinBloodMagic.Value);
			if (num < num2)
			{
				reason = $"Your Blood Magic is too weak to bind a soul ({num}/{num2}).";
				return false;
			}
			if (WispCount(player) <= 0)
			{
				reason = "You need a Wisp to bind the soul into.";
				return false;
			}
			return true;
		}

		public static float SealSeconds(Player player)
		{
			float num = Mathf.Max(0.1f, Plugin.SealChannelMaxSeconds.Value);
			float num2 = Mathf.Max(0.1f, Plugin.SealChannelMinSeconds.Value);
			if (num2 > num)
			{
				float num3 = num2;
				num2 = num;
				num = num3;
			}
			int num4 = Mathf.Max(0, Plugin.SealMinBloodMagic.Value);
			int num5 = Mathf.Max(num4 + 1, Plugin.SealFullSpeedBloodMagic.Value);
			float num6 = Mathf.Clamp01((float)(BloodMagicLevel(player) - num4) / (float)(num5 - num4));
			return Mathf.Lerp(num, num2, num6);
		}

		public static int BloodMagicLevel(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return 0;
			}
			try
			{
				Skills skills = ((Character)player).GetSkills();
				if ((Object)(object)skills == (Object)null)
				{
					return 0;
				}
				return Mathf.FloorToInt(skills.GetSkillLevel((SkillType)10));
			}
			catch
			{
				return 0;
			}
		}

		public static bool HasStaffEquipped(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			string text = StaffSharedName();
			if (string.IsNullOrEmpty(text))
			{
				return false;
			}
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (inventory == null)
			{
				return false;
			}
			foreach (ItemData equippedItem in inventory.GetEquippedItems())
			{
				if (equippedItem?.m_shared != null && equippedItem.m_shared.m_name == text)
				{
					return true;
				}
			}
			return false;
		}

		private static string StaffSharedName()
		{
			if (!string.IsNullOrEmpty(_staffSharedName))
			{
				return _staffSharedName;
			}
			GameObject val = (((Object)(object)ObjectDB.instance != (Object)null) ? ObjectDB.instance.GetItemPrefab("StaffSkeleton") : null);
			SharedData val2 = ((!((Object)(object)val != (Object)null)) ? null : val.GetComponent<ItemDrop>()?.m_itemData?.m_shared);
			if (val2 != null)
			{
				_staffSharedName = val2.m_name;
			}
			return _staffSharedName;
		}

		private static string WispName()
		{
			if (!string.IsNullOrEmpty(_wispSharedName))
			{
				return _wispSharedName;
			}
			_wispSharedName = TotemConversionService.WispSharedName();
			return _wispSharedName;
		}

		public static int WispCount(Player player)
		{
			string text = WispName();
			if ((Object)(object)player == (Object)null || string.IsNullOrEmpty(text))
			{
				return 0;
			}
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (inventory != null)
			{
				return inventory.CountItems(text, -1, true);
			}
			return 0;
		}

		public bool Begin(DvergrCompanion companion, Player player)
		{
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_target != (Object)null)
			{
				return false;
			}
			if (!CanSeal(player, companion, out var reason))
			{
				if (!string.IsNullOrEmpty(reason))
				{
					Msg(reason);
				}
				return false;
			}
			ZNetView component = ((Component)companion).GetComponent<ZNetView>();
			if ((Object)(object)component == (Object)null || !component.IsValid())
			{
				return false;
			}
			if (component.GetZDO().GetBool("DE_Sealing", false))
			{
				Msg("Another rite already has hold of it.");
				return false;
			}
			component.ClaimOwnership();
			component.GetZDO().Set("DE_Sealing", true);
			_target = companion;
			_player = player;
			_elapsed = 0f;
			_duration = SealSeconds(player);
			_beatTimer = 0f;
			_beatIndex = 0;
			_pulseTimer = 0f;
			_releaseGrace = 0f;
			_lastPlayerHealth = ((Character)player).GetHealth();
			CommunionRite.Instance?.PlayPulseAt(((Component)player).transform.position);
			CommunionRite.Instance?.PlayPulseAt(((Component)companion).transform.position);
			Msg("You raise the Dead Raiser — binding " + _target.DisplayName + " into a totem...");
			return true;
		}

		private void Update()
		{
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_target == (Object)null)
			{
				return;
			}
			Character val = (((Object)(object)_target != (Object)null) ? ((Component)_target).GetComponent<Character>() : null);
			if ((Object)(object)_player == (Object)null || (Object)(object)val == (Object)null || val.IsDead())
			{
				Fail("The binding slips away.");
				return;
			}
			if (!CanSeal(_player, _target, out var _))
			{
				Fail("The rite is broken — the binding needs staff, wisp and a following ally.");
				return;
			}
			if (CommunionRite.BlockHeld())
			{
				_releaseGrace = 0f;
			}
			else
			{
				_releaseGrace += Time.deltaTime;
				if (_releaseGrace >= 0.5f)
				{
					Fail("You lower the staff — the binding fails.");
					return;
				}
			}
			float num = Mathf.Max(1f, Plugin.SealMaxDistance.Value);
			if (Vector3.Distance(((Component)_player).transform.position, ((Component)_target).transform.position) > num)
			{
				Fail("You stray too far — the binding fails.");
				return;
			}
			float health = ((Character)_player).GetHealth();
			if (Plugin.CommunionBreakOnDamage.Value && health < _lastPlayerHealth - 0.5f)
			{
				Fail("Struck mid-rite — the binding fails.");
				return;
			}
			_lastPlayerHealth = health;
			_elapsed += Time.deltaTime;
			float num2 = Mathf.Clamp01(_elapsed / Mathf.Max(0.1f, _duration));
			_pulseTimer += Time.deltaTime;
			if (_pulseTimer >= Mathf.Lerp(1f, 0.28f, num2))
			{
				_pulseTimer = 0f;
				CommunionRite.Instance?.PlayPulseAt(((Component)_target).transform.position);
				CommunionRite.Instance?.PlayPulseAt(((Component)_player).transform.position);
			}
			_beatTimer += Time.deltaTime;
			if (_beatTimer >= 1.25f)
			{
				_beatTimer = 0f;
				Msg(BeatLines[_beatIndex % BeatLines.Length]);
				_beatIndex++;
			}
			if (_elapsed >= _duration)
			{
				Succeed();
			}
		}

		private void Succeed()
		{
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			DvergrCompanion target = _target;
			Player player = _player;
			ClearLock(target);
			Reset();
			if ((Object)(object)target == (Object)null || (Object)(object)player == (Object)null)
			{
				return;
			}
			ItemData val = TotemConversionService.CreateTotem(target);
			if (val == null)
			{
				Msg("The binding finds no vessel.");
				return;
			}
			Inventory inventory = ((Humanoid)player).GetInventory();
			string text = WispName();
			if (inventory == null || string.IsNullOrEmpty(text) || inventory.CountItems(text, -1, true) <= 0)
			{
				Msg("The wisp is gone — the binding fails.");
				return;
			}
			inventory.RemoveItem(text, 1, -1, true);
			if (!inventory.AddItem(val))
			{
				ItemDrop.DropItem(val, 1, ((Component)player).transform.position + Vector3.up, ((Component)player).transform.rotation);
				Msg("Your pack is full — the totem falls at your feet.");
			}
			TotemConversionService.PlaySealVfx(((Component)target).transform.position + Vector3.up);
			Plugin.Log.LogInfo((object)("[totem] " + player.GetPlayerName() + " sealed '" + target.DisplayName + "' with a Dead Raiser."));
			Msg(target.DisplayName + " is sealed within a totem.");
			target.DespawnToTotem();
		}

		private void Fail(string message)
		{
			ClearLock(_target);
			Reset();
			Msg(message);
		}

		private static void ClearLock(DvergrCompanion companion)
		{
			if (!((Object)(object)companion == (Object)null))
			{
				ZNetView component = ((Component)companion).GetComponent<ZNetView>();
				if ((Object)(object)component != (Object)null && component.IsValid() && component.IsOwner())
				{
					component.GetZDO().Set("DE_Sealing", false);
				}
			}
		}

		private void Reset()
		{
			_target = null;
			_player = null;
			_elapsed = 0f;
			_beatTimer = 0f;
			_beatIndex = 0;
			_pulseTimer = 0f;
			_releaseGrace = 0f;
		}

		private static void Msg(string m)
		{
			if (!string.IsNullOrEmpty(m) && (Object)(object)MessageHud.instance != (Object)null)
			{
				MessageHud.instance.ShowMessage((MessageType)2, m, 0, (Sprite)null, false);
			}
		}
	}
	public class ShipRideAI : MonoBehaviour
	{
		private const float LadderBoardRange = 3.5f;

		private const float HullBoardRange = 5f;

		private const float BoardCooldown = 1.5f;

		private const float ScanInterval = 0.4f;

		private Character _character;

		private MonsterAI _ai;

		private ZNetView _znv;

		private DvergrCompanion _companion;

		private Rigidbody _body;

		private float _scanTimer;

		private float _lastBoardTime = -999f;

		private bool _wasAboard;

		private bool IsDriver
		{
			get
			{
				if (!((Object)(object)_znv == (Object)null) && _znv.IsValid())
				{
					return _znv.IsOwner();
				}
				return true;
			}
		}

		private bool Eligible
		{
			get
			{
				if ((Object)(object)_companion != (Object)null && _companion.Stance == CompanionStance.Follow && !_companion.ChoreActive && !_companion.DuelMode)
				{
					return !_companion.IsFeral;
				}
				return false;
			}
		}

		private void Awake()
		{
			_character = ((Component)this).GetComponent<Character>();
			_ai = ((Component)this).GetComponent<MonsterAI>();
			_znv = ((Component)this).GetComponent<ZNetView>();
			_companion = ((Component)this).GetComponent<DvergrCompanion>();
			_body = (((Object)(object)_character != (Object)null) ? _character.m_body : null);
		}

		private void Update()
		{
			if (!IsDriver || (Object)(object)_character == (Object)null || (Object)(object)_ai == (Object)null)
			{
				return;
			}
			_scanTimer += Time.deltaTime;
			if (_scanTimer < 0.4f)
			{
				return;
			}
			_scanTimer = 0f;
			if (!Eligible)
			{
				_wasAboard = false;
				SetAvoidWater(avoid: true);
				return;
			}
			Player val = _companion.OwnerPlayer();
			Ship val2 = (((Object)(object)val != (Object)null) ? FindShipCarrying(val) : null);
			SetAvoidWater((Object)(object)val2 == (Object)null);
			if ((Object)(object)val2 == (Object)null)
			{
				_wasAboard = false;
			}
			else if ((Object)(object)_character.GetStandingOnShip() == (Object)(object)val2)
			{
				_wasAboard = true;
			}
			else if (!(Time.time - _lastBoardTime < 1.5f))
			{
				TryBoard(val2);
			}
		}

		private void TryBoard(Ship ship)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = ((Component)this).transform.position;
			Ladder val = null;
			float num = float.MaxValue;
			Ladder[] componentsInChildren = ((Component)ship).GetComponentsInChildren<Ladder>();
			foreach (Ladder val2 in componentsInChildren)
			{
				if (!((Object)(object)val2 == (Object)null))
				{
					float num2 = HorizontalDistance(position, ((Component)val2).transform.position);
					if (num2 < num)
					{
						num = num2;
						val = val2;
					}
				}
			}
			if ((Object)(object)val != (Object)null && num <= 3.5f)
			{
				Vector3 deckPoint = (((Object)(object)val.m_targetPos != (Object)null) ? val.m_targetPos.position : (((Component)val).transform.position + Vector3.up * 1.5f));
				Board(deckPoint);
			}
			else if ((Object)(object)val == (Object)null && HorizontalDistance(position, ((Component)ship).transform.position) <= 5f)
			{
				Player val3 = _companion.OwnerPlayer();
				Vector3 val4 = (((Object)(object)val3 != (Object)null) ? ((Component)val3).transform.position : ((Component)ship).transform.position);
				Board(val4 + ((Component)ship).transform.right * 0.8f);
			}
		}

		private void Board(Vector3 deckPoint)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_body != (Object)null)
			{
				_body.position = deckPoint;
				_body.rotation = ((Component)this).transform.rotation;
			}
			((Component)this).transform.position = deckPoint;
			_lastBoardTime = Time.time;
			if (!_wasAboard)
			{
				_companion.AnnounceBoarded();
			}
			_wasAboard = true;
		}

		private void SetAvoidWater(bool avoid)
		{
			if ((Object)(object)_ai != (Object)null && ((BaseAI)_ai).m_avoidWater != avoid)
			{
				((BaseAI)_ai).m_avoidWater = avoid;
			}
		}

		private static Ship FindShipCarrying(Player owner)
		{
			if ((Object)(object)owner == (Object)null || Ship.s_currentShips == null)
			{
				return null;
			}
			foreach (Ship s_currentShip in Ship.s_currentShips)
			{
				if ((Object)(object)s_currentShip != (Object)null && s_currentShip.IsPlayerInBoat(owner))
				{
					return s_currentShip;
				}
			}
			return null;
		}

		private static float HorizontalDistance(Vector3 a, Vector3 b)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			a.y = 0f;
			b.y = 0f;
			return Vector3.Distance(a, b);
		}
	}
	public static class TotemConversionService
	{
		public const string TotemPrefab = "GoblinTotem";

		public const string WispPrefab = "Wisp";

		public const string ItemName = "Communion Totem";

		public const string ItemDescription = "A vessel of the Communion Rite. Within slumbers a freed Dvergr, bound to the totem until you call it forth again.";

		private static readonly string[] SealFx = new string[3] { "vfx_ghost_death", "fx_spawn_smoke", "vfx_spawn" };

		private static readonly string[] SummonFx = new string[3] { "vfx_spawn", "fx_spawn_smoke", "vfx_ghost_death" };

		private static readonly MethodInfo MemberwiseCloneMethod = typeof(object).GetMethod("MemberwiseClone", BindingFlags.Instance | BindingFlags.NonPublic);

		private const string KeyMarker = "DE_Totem";

		private const string KeyCaste = "DE_TotemCaste";

		private const string KeyLevel = "DE_TotemLevel";

		private const string KeyXp = "DE_TotemXp";

		private const string KeyName = "DE_TotemName";

		private const string KeyOwner = "DE_TotemOwner";

		private const string KeyOwnerName = "DE_TotemOwnerName";

		private const string KeyInv = "DE_TotemInv";

		private const string KeyId = "DE_TotemId";

		private static string _wispSharedName;

		public static string WispSharedName()
		{
			if (!string.IsNullOrEmpty(_wispSharedName))
			{
				return _wispSharedName;
			}
			GameObject val = (((Object)(object)ObjectDB.instance != (Object)null) ? ObjectDB.instance.GetItemPrefab("Wisp") : null);
			SharedData val2 = ((!((Object)(object)val != (Object)null)) ? null : val.GetComponent<ItemDrop>()?.m_itemData?.m_shared);
			if (val2 != null)
			{
				_wispSharedName = val2.m_name;
			}
			return _wispSharedName;
		}

		public static bool IsCompanionTotem(ItemData item)
		{
			if (item?.m_customData != null)
			{
				return item.m_customData.ContainsKey("DE_Totem");
			}
			return false;
		}

		public static string CompanionIdOf(ItemData item)
		{
			return GetStr(item, "DE_TotemId");
		}

		public static DvergrCaste CasteOf(ItemData item)
		{
			return (DvergrCaste)GetInt(item, "DE_TotemCaste", 0);
		}

		public static int LevelOf(ItemData item)
		{
			return GetInt(item, "DE_TotemLevel", 1);
		}

		public static string LabelOf(ItemData item)
		{
			string str = GetStr(item, "DE_TotemName");
			if (!string.IsNullOrEmpty(str))
			{
				return str;
			}
			return CasteOf(item).Display();
		}

		public static string SerializePayload(ItemData item)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			if (item?.m_customData == null)
			{
				return string.Empty;
			}
			ZPackage val = new ZPackage();
			val.Write(item.m_customData.Count);
			foreach (KeyValuePair<string, string> customDatum in item.m_customData)
			{
				val.Write(customDatum.Key ?? string.Empty);
				val.Write(customDatum.Value ?? string.Empty);
			}
			val.Write(item.m_crafterName ?? string.Empty);
			val.Write(item.m_crafterID);
			return val.GetBase64();
		}

		public static ItemData BuildTotemFromPayload(string payload)
		{
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Expected O, but got Unknown
			if (string.IsNullOrEmpty(payload))
			{
				return null;
			}
			GameObject val = (((Object)(object)ObjectDB.instance != (Object)null) ? ObjectDB.instance.GetItemPrefab("GoblinTotem") : null);
			ItemDrop val2 = (((Object)(object)val != (Object)null) ? val.GetComponent<ItemDrop>() : null);
			if ((Object)(object)val2 == (Object)null)
			{
				Plugin.Log.LogWarning((object)"[totem] 'GoblinTotem' prefab not found — cannot rebuild escrowed totem.");
				return null;
			}
			ItemData val3 = val2.m_itemData.Clone();
			val3.m_dropPrefab = val;
			val3.m_stack = 1;
			val3.m_quality = 1;
			val3.m_worldLevel = (byte)Game.m_worldLevel;
			try
			{
				ZPackage val4 = new ZPackage(payload);
				int num = val4.ReadInt();
				val3.m_customData.Clear();
				for (int i = 0; i < num; i++)
				{
					string key = val4.ReadString();
					string value = val4.ReadString();
					val3.m_customData[key] = value;
				}
				val3.m_crafterName = val4.ReadString();
				val3.m_crafterID = val4.ReadLong();
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[totem] Failed to rebuild escrowed totem: " + ex.Message));
				return null;
			}
			ApplyTotemShared(val3);
			return val3;
		}

		public static ItemData CreateTotem(DvergrCompanion companion)
		{
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Expected O, but got Unknown
			if ((Object)(object)companion == (Object)null)
			{
				return null;
			}
			GameObject val = (((Object)(object)ObjectDB.instance != (Object)null) ? ObjectDB.instance.GetItemPrefab("GoblinTotem") : null);
			ItemDrop val2 = (((Object)(object)val != (Object)null) ? val.GetComponent<ItemDrop>() : null);
			if ((Object)(object)val2 == (Object)null)
			{
				Plugin.Log.LogWarning((object)"[totem] 'GoblinTotem' prefab not found in ObjectDB — cannot seal companion.");
				return null;
			}
			ItemData obj = val2.m_itemData.Clone();
			obj.m_dropPrefab = val;
			obj.m_stack = 1;
			obj.m_quality = 1;
			obj.m_worldLevel = (byte)Game.m_worldLevel;
			obj.m_crafterName = companion.DisplayName;
			obj.m_crafterID = companion.OwnerId;
			Dictionary<string, string> customData = obj.m_customData;
			customData["DE_Totem"] = "1";
			customData["DE_TotemCaste"] = ((int)companion.Caste).ToString(CultureInfo.InvariantCulture);
			customData["DE_TotemLevel"] = companion.Level.ToString(CultureInfo.InvariantCulture);
			customData["DE_TotemXp"] = companion.Xp.ToString("R", CultureInfo.InvariantCulture);
			customData["DE_TotemName"] = (companion.HasCustomName ? companion.DisplayName : string.Empty);
			customData["DE_TotemOwner"] = companion.OwnerId.ToString(CultureInfo.InvariantCulture);
			customData["DE_TotemOwnerName"] = companion.OwnerName ?? string.Empty;
			customData["DE_TotemId"] = companion.EnsureCompanionId() ?? string.Empty;
			CompanionInventory component = ((Component)companion).GetComponent<CompanionInventory>();
			if ((Object)(object)component != (Object)null && component.Inventory != null && component.Inventory.NrOfItems() > 0)
			{
				ZPackage val3 = new ZPackage();
				component.Inventory.Save(val3);
				customData["DE_TotemInv"] = val3.GetBase64();
			}
			ApplyTotemShared(obj);
			return obj;
		}

		public static void ApplyTotemShared(ItemData item)
		{
			if (item?.m_shared != null && !(MemberwiseCloneMethod == null))
			{
				object? obj = MemberwiseCloneMethod.Invoke(item.m_shared, null);
				SharedData val = (SharedData)((obj is SharedData) ? obj : null);
				if (val != null)
				{
					val.m_name = "Communion Totem";
					val.m_description = "A vessel of the Communion Rite. Within slumbers a freed Dvergr, bound to the totem until you call it forth again.";
					val.m_maxStackSize = 1;
					item.m_shared = val;
				}
			}
		}

		public static void ReapplyTotemShared(ItemData item)
		{
			if (IsCompanionTotem(item) && (item.m_shared == null || !(item.m_shared.m_name == "Communion Totem")))
			{
				ApplyTotemShared(item);
			}
		}

		public static bool TrySummon(Player player, ItemData totem)
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null || !IsCompanionTotem(totem))
			{
				return false;
			}
			if (!TryGetAimPoint(player, out var point))
			{
				return false;
			}
			DvergrCaste dvergrCaste = (DvergrCaste)GetInt(totem, "DE_TotemCaste", 0);
			int num = Mathf.Clamp(GetInt(totem, "DE_TotemLevel", 1), 1, 10);
			float xp = GetFloat(totem, "DE_TotemXp", 0f);
			string str = GetStr(totem, "DE_TotemName");
			string str2 = GetStr(totem, "DE_TotemId");
			GameObject val = CommunionService.SpawnRecruited(dvergrCaste, num, player, point + Vector3.up * 0.5f, xp, string.IsNullOrEmpty(str2) ? null : str2);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			if (!string.IsNullOrEmpty(str))
			{
				val.GetComponent<DvergrCompanion>()?.SetName(str);
			}
			RestoreInventory(totem, val);
			PlaySummonVfx(val.transform.position);
			Plugin.Log.LogInfo((object)$"[totem] Summoned {dvergrCaste} (lv {num}) from totem for {player.GetPlayerName()}.");
			return true;
		}

		public static GameObject SummonAt(Player owner, ItemData totem, Vector3 pos)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)owner == (Object)null || !IsCompanionTotem(totem))
			{
				return null;
			}
			DvergrCaste caste = CasteOf(totem);
			int level = Mathf.Clamp(LevelOf(totem), 1, 10);
			float xp = GetFloat(totem, "DE_TotemXp", 0f);
			string str = GetStr(totem, "DE_TotemName");
			string str2 = GetStr(totem, "DE_TotemId");
			GameObject val = CommunionService.SpawnRecruited(caste, level, owner, pos + Vector3.up * 0.5f, xp, string.IsNullOrEmpty(str2) ? null : str2);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			if (!string.IsNullOrEmpty(str))
			{
				val.GetComponent<DvergrCompanion>()?.SetName(str);
			}
			RestoreInventory(totem, val);
			PlaySummonVfx(val.transform.position);
			return val;
		}

		private static void RestoreInventory(ItemData totem, GameObject go)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			string str = GetStr(totem, "DE_TotemInv");
			if (string.IsNullOrEmpty(str))
			{
				return;
			}
			CompanionInventory companionInventory = go.GetComponent<CompanionInventory>();
			if ((Object)(object)companionInventory == (Object)null)
			{
				companionInventory = go.AddComponent<CompanionInventory>();
			}
			companionInventory.EnsureContainer();
			if (companionInventory.Inventory == null)
			{
				return;
			}
			try
			{
				companionInventory.Inventory.Load(new ZPackage(str));
				Container container = companionInventory.Container;
				if (container != null)
				{
					container.Save();
				}
				Plugin.Log.LogInfo((object)$"[totem] Restored {companionInventory.Inventory.NrOfItems()} pack item(s) to the summoned companion.");
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[totem] Failed to restore sealed pack: " + ex.Message));
			}
		}

		public static void PlaySealVfx(Vector3 pos)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			PlayEffect(SealFx, pos);
		}

		public static void PlaySummonVfx(Vector3 pos)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			PlayEffect(SummonFx, pos);
		}

		private static void PlayEffect(string[] candidates, Vector3 pos)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ZNetScene.instance == (Object)null)
			{
				return;
			}
			foreach (string text in candidates)
			{
				GameObject prefab = ZNetScene.instance.GetPrefab(text);
				if (!((Object)(object)prefab == (Object)null))
				{
					EffectList val = new EffectList();
					val.m_effectPrefabs = (EffectData[])(object)new EffectData[1]
					{
						new EffectData
						{
							m_prefab = prefab,
							m_enabled = true
						}
					};
					val.Create(pos, Quaternion.identity, (Transform)null, 1f, -1);
					return;
				}
			}
			Plugin.Log.LogWarning((object)("[totem] No VFX prefab resolved (tried: " + string.Join(", ", candidates) + ")."));
		}

		private static bool TryGetAimPoint(Player player, out Vector3 point)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			point = Vector3.zero;
			GameCamera instance = GameCamera.instance;
			if ((Object)(object)instance != (Object)null)
			{
				int mask = LayerMask.GetMask(new string[6] { "Default", "static_solid", "Default_small", "piece", "terrain", "vehicle" });
				RaycastHit val = default(RaycastHit);
				if (Physics.Raycast(((Component)instance).transform.position, ((Component)instance).transform.forward, ref val, 50f, mask))
				{
					point = ((RaycastHit)(ref val)).point;
					return true;
				}
			}
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			point = ((Component)player).transform.position + ((Component)player).transform.forward * 4f;
			return true;
		}

		public static string BuildTooltipBlock(ItemData item)
		{
			DvergrCaste caste = (DvergrCaste)GetInt(item, "DE_TotemCaste", 0);
			int num = GetInt(item, "DE_TotemLevel", 1);
			string value = GetStr(item, "DE_TotemName");
			string str = GetStr(item, "DE_TotemOwnerName");
			if (string.IsNullOrEmpty(value))
			{
				value = caste.Display();
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("\n\n<color=#FFD24A>⚔ ").Append(value).Append("</color>");
			stringBuilder.Append("\n").Append(caste.Display()).Append(" — <color=orange>Level ")
				.Append(num)
				.Append("</color>");
			if (num >= 10)
			{
				stringBuilder.Append(" (max)");
			}
			if (!string.IsNullOrEmpty(str))
			{
				stringBuilder.Append("\nBound to <color=orange>").Append(str).Append("</color>");
			}
			stringBuilder.Append("\n\n<color=#AAAAAA>Use to summon this companion where you are looking.</color>");
			return stringBuilder.ToString();
		}

		private static int GetInt(ItemData item, string key, int fallback)
		{
			if (item?.m_customData != null && item.m_customData.TryGetValue(key, out var value) && int.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
			{
				return result;
			}
			return fallback;
		}

		private static float GetFloat(ItemData item, string key, float fallback)
		{
			if (item?.m_customData != null && item.m_customData.TryGetValue(key, out var value) && float.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
			{
				return result;
			}
			return fallback;
		}

		private static string GetStr(ItemData item, string key)
		{
			if (item?.m_customData != null && item.m_customData.TryGetValue(key, out var value))
			{
				return value;
			}
			return string.Empty;
		}
	}
	public static class TournamentBoard
	{
		public static void Open(Player player)
		{
			if ((Object)(object)TextViewer.instance == (Object)null)
			{
				if ((Object)(object)MessageHud.instance != (Object)null)
				{
					MessageHud.instance.ShowMessage((MessageType)2, "The tournament board isn't available right now.", 0, (Sprite)null, false);
				}
				return;
			}
			LeaderboardSync.RequestTournament();
			LeaderboardSync.RequestInvites();
			if ((Object)(object)Plugin.Instance != (Object)null)
			{
				((MonoBehaviour)Plugin.Instance).StartCoroutine(ShowAfterSync(player));
			}
			else
			{
				Show(player);
			}
		}

		private static IEnumerator ShowAfterSync(Player player)
		{
			yield return (object)new WaitForSeconds(0.25f);
			Show(player);
		}

		private static void Show(Player player)
		{
			if (!((Object)(object)TextViewer.instance == (Object)null))
			{
				TextViewer.instance.ShowText((Style)0, "Dvergr Tournament", Build(player), false);
			}
		}

		private static string Build(Player player)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("<align=left>");
			List<TournamentState> list = TournamentService.All.ToList();
			if (list.Count == 0)
			{
				stringBuilder.Append("<size=140%><color=#FFD24A>No tournament is running.</color></size>\n\n");
				stringBuilder.Append("<color=#AAAAAA>Any player can open one from the Tournament panel (");
				stringBuilder.Append($"[{Plugin.TournamentUiKey.Value}]");
				stringBuilder.Append(") by paying the entry stake — one Coin tournament and one Valcoin tournament may run at a time. ");
				stringBuilder.Append("Admins can also start a free one. When registration opens, lock a companion's Communion Totem into a slot to enter.</color>\n");
			}
			else
			{
				bool flag = true;
				foreach (TournamentState item in list)
				{
					if (!flag)
					{
						stringBuilder.Append("\n<color=#555555>--------------------</color>\n\n");
					}
					flag = false;
					AppendTournament(stringBuilder, item);
				}
			}
			AppendInvites(stringBuilder, player);
			stringBuilder.Append("</align>");
			return stringBuilder.ToString();
		}

		private static void AppendTournament(StringBuilder sb, TournamentState s)
		{
			string text = ((s.mode == "party") ? "Party" : "1v1");
			string text2 = TypeLabel(s.eliminationType);
			WagerCurrency c = Wager.Parse(s.currency);
			string text3 = ((s.entryFee > 0) ? $"  <color=#B8F5B0>{s.entryFee} {Wager.Display(c)} entry, {s.prize} to the champion</color>" : "");
			sb.Append("<size=150%><color=#FFD24A>" + Title(s) + "</color></size>  <color=#AAAAAA>(" + s.phase + " — " + text + ", " + text2 + ")</color>" + text3 + "\n");
			if (s.entryFee > 0 && !string.IsNullOrEmpty(s.hostName))
			{
				sb.Append("<color=#AAAAAA>Opened by " + s.hostName + "</color>\n");
			}
			sb.Append("\n");
			if (s.phase == "registration")
			{
				int num = ((s.size > 0) ? s.size : 0);
				sb.Append($"<color=#FFFFFF>Registration is open</color> — {s.entrants.Count}");
				sb.Append((num > 0) ? $" / {num} entrants:\n" : " entrants:\n");
				AppendEntrants(sb, s);
				sb.Append("\n<color=#AAAAAA>Enter by locking a companion's Communion Totem into a slot (open the registration panel from this board). ");
				sb.Append((s.entryFee > 0) ? "The bracket begins automatically the moment it fills; if it never fills, every stake and totem is returned.</color>\n" : "An admin begins the bracket when everyone's in.</color>\n");
			}
			else if (s.phase == "running")
			{
				sb.Append($"<color=#FFFFFF>Round {s.currentRound}</color> — the bracket is live:\n");
				AppendBracket(sb, s);
				sb.Append("\n");
				AppendStandings(sb, s);
				sb.Append((s.entryFee > 0) ? "\n<color=#AAAAAA>You and your opponent pick where to fight: meet up anywhere, then both press Ready to Fight on the Tournament panel. Your companions are summoned there, at full health.</color>\n" : "\n<color=#AAAAAA>Fight your pairing to advance. An admin activates each round.</color>\n");
			}
			else if (s.phase == "complete")
			{
				string text4 = (string.IsNullOrEmpty(s.championLabel) ? "?" : s.championLabel);
				sb.Append("<size=140%><color=#FFD24A>Champion: " + text4 + "</color></size>\n\n");
				AppendStandings(sb, s);
				sb.Append("\n<color=#AAAAAA>See the Hall of Champions with de_champions.</color>\n");
			}
		}

		private static void AppendInvites(StringBuilder sb, Player player)
		{
			List<DuelInvite> list = DuelInviteService.All.ToList();
			if (list.Count == 0)
			{
				return;
			}
			sb.Append("\n<color=#555555>--------------------</color>\n\n");
			sb.Append("<size=150%><color=#FFD24A>Duel Invites</color></size>\n\n");
			long ownerId = (((Object)(object)player != (Object)null) ? player.GetPlayerID() : 0);
			foreach (DuelInvite item in list)
			{
				string text = Wager.Display(Wager.Parse(item.currency));
				string text2 = (item.Involves(ownerId) ? " <color=#B8F5B0>(yours)</color>" : "");
				string text3 = item.phase switch
				{
					"matched" => "<color=#FFD24A>" + item.oppLabel + " (" + item.oppName + ") accepted — waiting for both to be ready</color>", 
					"running" => "<color=#E06666>fighting now</color>", 
					"complete" => "<color=#AAAAAA>settled</color>", 
					_ => "<color=#8FE3FF>open — anyone may accept</color>", 
				};
				sb.Append("  " + LabelWithLevel(item.hostLabel, item.hostLevel) + " <color=#AAAAAA>(" + item.hostName + ")</color>" + text2 + "\n");
				sb.Append($"     stake <color=#B8F5B0>{item.stake} {text}</color>, winner takes <color=#B8F5B0>{item.stake * 2}</color> — {text3}\n");
			}
			sb.Append("\n<color=#AAAAAA>Post or accept an invite from the Tournament panel. You may only be in one invite at a time, and the two of you choose where to fight.</color>\n");
		}

		private static string Title(TournamentState s)
		{
			WagerCurrency wagerCurrency = Wager.Parse(s.currency);
			if (wagerCurrency != WagerCurrency.None)
			{
				return Wager.Display(wagerCurrency) + " Tournament";
			}
			return "Server Tournament";
		}

		private static void AppendEntrants(StringBuilder sb, TournamentState s)
		{
			if (s.entrants.Count == 0)
			{
				sb.Append("<color=#AAAAAA>  (none yet)</color>\n");
				return;
			}
			foreach (TournamentEntrant entrant in s.entrants)
			{
				string text = (string.IsNullOrEmpty(entrant.label) ? "?" : entrant.label);
				string text2 = (string.IsNullOrEmpty(entrant.ownerName) ? "?" : entrant.ownerName);
				string text3 = ((entrant.level > 0) ? $" <color=#FFD24A>Lv{entrant.level}</color>" : "");
				sb.Append($"  {text}{text3} <color=#AAAAAA>({text2})</color>  <color=#8FE3FF>{entrant.seedRating}</color>\n");
			}
		}

		private static void AppendBracket(StringBuilder sb, TournamentState s)
		{
			int num = 0;
			foreach (TournamentMatch match in s.matches)
			{
				if (match.round > num)
				{
					num = match.round;
				}
			}
			bool flag = s.eliminationType == "double";
			for (int i = 1; i <= num; i++)
			{
				sb.Append($"<color=#FFD24A>-- Round {i} --</color>\n");
				foreach (TournamentMatch match2 in s.matches)
				{
					if (match2.round == i)
					{
						string text = (flag ? ("<color=#AAAAAA>[" + match2.bracket + "]</color> ") : "");
						string text2 = LabelWithLevel(match2.aLabel, match2.aLevel);
						string text3 = (string.IsNullOrEmpty(match2.bId) ? "(bye)" : LabelWithLevel(match2.bLabel, match2.bLevel));
						string text4 = ((!string.IsNullOrEmpty(match2.winnerId)) ? ("<color=#B8F5B0>winner: " + ((match2.winnerId == match2.aId) ? match2.aLabel : match2.bLabel) + "</color>") : ((!match2.activated) ? ("<color=#AAAAAA>ready: " + (match2.aReady ? "yes" : "no") + " / " + (match2.bReady ? "yes" : "no") + "</color>") : "<color=#E06666>fighting</color>"));
						sb.Append("  " + text + text2 + " <color=#AAAAAA>vs</color> " + text3 + " — " + text4 + "\n");
					}
				}
			}
		}

		private static void AppendStandings(StringBuilder sb, TournamentState s)
		{
			if (s.entrants.Count == 0)
			{
				return;
			}
			sb.Append("<color=#FFD24A>-- Standings --</color>\n");
			foreach (TournamentEntrant item in (s.eliminationType == "round_robin") ? (from e in s.entrants
				orderby e.wins descending, e.losses, e.seedRating descending
				select e) : (from e in s.entrants
				orderby e.eliminated ? 1 : 0, e.wins descending, e.losses
				select e))
			{
				string text = (string.IsNullOrEmpty(item.label) ? "?" : item.label);
				string text2 = $"{item.wins}-{item.losses}";
				string text3 = (item.eliminated ? " <color=#E06666>(eliminated)</color>" : ((item.entrantId == s.championId) ? " <color=#FFD24A>(champion)</color>" : ""));
				sb.Append("  " + text + " <color=#8FE3FF>" + text2 + "</color>" + text3 + "\n");
			}
		}

		private static string LabelWithLevel(string label, int level)
		{
			if (level <= 0)
			{
				return label;
			}
			return $"{label} <color=#FFD24A>Lv{level}</color>";
		}

		private static string TypeLabel(string eliminationType)
		{
			if (!(eliminationType == "double"))
			{
				if (eliminationType == "round_robin")
				{
					return "round robin";
				}
				return "single elim";
			}
			return "double elim";
		}
	}
	public class TournamentCombatant : MonoBehaviour
	{
		public string EntrantId;

		public bool Party;

		public int Round;

		public string Context = "tourney";
	}
	public class TournamentClient : MonoBehaviour
	{
		private static TournamentClient _instance;

		private float _tick;

		private static readonly Dictionary<string, List<DvergrCompanion>> _byEntrant = new Dictionary<string, List<DvergrCompanion>>();

		private void Awake()
		{
			_instance = this;
		}

		public static void SummonForMatch(Player owner, string entrantId, string mode, string opponentEntrantId, string opponentLabel, int round, List<string> payloads, string context = null)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)owner == (Object)null || payloads == null || payloads.Count == 0)
			{
				return;
			}
			bool flag = mode == "party";
			long result = 0L;
			if (flag)
			{
				long.TryParse(opponentEntrantId, out result);
			}
			int num = 0;
			int num2 = 0;
			foreach (string payload in payloads)
			{
				ItemData val = TotemConversionService.BuildTotemFromPayload(payload);
				if (val == null)
				{
					continue;
				}
				Vector3 pos = ((Component)owner).transform.position + ((Component)owner).transform.forward * 1.5f + ((Component)owner).transform.right * ((num % 2 == 0) ? 1.4f : (-1.4f)) * (float)(1 + num / 2);
				GameObject val2 = TotemConversionService.SummonAt(owner, val, pos);
				DvergrCompanion dvergrCompanion = (((Object)(object)val2 != (Object)null) ? val2.GetComponent<DvergrCompanion>() : null);
				if (!((Object)(object)dvergrCompanion == (Object)null))
				{
					Character component = val2.GetComponent<Character>();
					if ((Object)(object)component != (Object)null)
					{
						component.Heal(component.GetMaxHealth(), true);
					}
					if (flag)
					{
						dvergrCompanion.DuelOpponentOwner = result;
						dvergrCompanion.EnterPartyDuelMode();
					}
					else
					{
						dvergrCompanion.DuelOpponentId = opponentEntrantId;
						dvergrCompanion.EnterDuelMode();
					}
					TournamentCombatant obj = val2.GetComponent<TournamentCombatant>() ?? val2.AddComponent<TournamentCombatant>();
					obj.EntrantId = entrantId;
					obj.Party = flag;
					obj.Round = round;
					obj.Context = (string.IsNullOrEmpty(context) ? "tourney" : context);
					num++;
					num2++;
				}
			}
			if (num2 > 0 && (Object)(object)MessageHud.instance != (Object)null)
			{
				MessageHud.instance.ShowMessage((MessageType)1, "Your companion enters the arena — opponent: " + opponentLabel + ".", 0, (Sprite)null, false);
			}
		}

		private void Update()
		{
			_tick += Time.deltaTime;
			if (!(_tick < 1f))
			{
				_tick = 0f;
				ResolveFinishedMatches();
				if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
				{
					TournamentService.Tick();
					DuelInviteService.Tick();
				}
			}
		}

		private void ResolveFinishedMatches()
		{
			_byEntrant.Clear();
			foreach (DvergrCompanion item in DvergrCompanion.All)
			{
				if ((Object)(object)item == (Object)null)
				{
					continue;
				}
				TournamentCombatant component = ((Component)item).GetComponent<TournamentCombatant>();
				if (!((Object)(object)component == (Object)null) && !string.IsNullOrEmpty(component.EntrantId))
				{
					if (!_byEntrant.TryGetValue(component.EntrantId, out var value))
					{
						value = new List<DvergrCompanion>();
						_byEntrant[component.EntrantId] = value;
					}
					value.Add(item);
				}
			}
			if (_byEntrant.Count == 0)
			{
				return;
			}
			foreach (KeyValuePair<string, List<DvergrCompanion>> item2 in _byEntrant)
			{
				string key = item2.Key;
				List<DvergrCompanion> value2 = item2.Value;
				TournamentCombatant component2 = ((Component)value2[0]).GetComponent<TournamentCombatant>();
				int round = component2?.Round ?? 0;
				string context = component2?.Context ?? "tourney";
				if (!MatchDecided(key, round, context))
				{
					continue;
				}
				List<string> list = new List<string>();
				foreach (DvergrCompanion item3 in value2)
				{
					ItemData val = TotemConversionService.CreateTotem(item3);
					if (val != null)
					{
						list.Add(TotemConversionService.SerializePayload(val));
					}
				}
				if (list.Count > 0)
				{
					LeaderboardSync.SendReseal(key, list);
				}
				foreach (DvergrCompanion item4 in value2)
				{
					item4.DespawnToTotem();
				}
			}
		}

		private static bool MatchDecided(string entrantId, int round, string context)
		{
			if (context == "invite")
			{
				DuelInvite duelInvite = DuelInviteService.FindByEntrant(entrantId);
				if (duelInvite != null)
				{
					return duelInvite.phase != "running";
				}
				return true;
			}
			TournamentState tournamentState = TournamentService.FindByEntrant(entrantId);
			if (tournamentState == null || !tournamentState.active || tournamentState.phase != "running")
			{
				return true;
			}
			foreach (TournamentMatch match in tournamentState.matches)
			{
				if (match.round == round && (match.aId == entrantId || match.bId == entrantId))
				{
					return !string.IsNullOrEmpty(match.winnerId);
				}
			}
			return true;
		}
	}
	public class TournamentRegistration : MonoBehaviour
	{
		private static TournamentRegistration _instance;

		private GameObject _root;

		private TMP_Text _status;

		private readonly List<GameObject> _buttons = new List<GameObject>();

		private TMP_Text _textSource;

		private Button _buttonSource;

		private string _lastSig;

		private static readonly string[] EliminationTypes = new string[3] { "single", "double", "round_robin" };

		private int _pendingTypeIndex;

		private const float PanelWidth = 860f;

		private const float PanelHeight = 940f;

		private const float StatusTopY = 446f;

		private const float PanelBottomY = -470f;

		private const float StatusGap = 22f;

		private const float MinColumnHeight = 240f;

		private static readonly string[] Slots = new string[3] { "coins", "valcoin", "" };

		private int _slotIndex;

		public static bool IsOpen { get; private set; }

		private string CurrentSlot => Slots[Mathf.Clamp(_slotIndex, 0, Slots.Length - 1)];

		private static string DisplayType(string t)
		{
			if (!(t == "double"))
			{
				if (t == "round_robin")
				{
					return "Round Robin";
				}
				return "Single Elim";
			}
			return "Double Elim";
		}

		private void Awake()
		{
			_instance = this;
		}

		public static void Toggle(Player player)
		{
			if (!((Object)(object)_instance == (Object)null))
			{
				if (IsOpen)
				{
					_instance.Close();
				}
				else
				{
					_instance.Open(player);
				}
			}
		}

		private void Open(Player player)
		{
			if ((Object)(object)InventoryGui.instance == (Object)null)
			{
				if ((Object)(object)MessageHud.instance != (Object)null)
				{
					MessageHud.instance.ShowMessage((MessageType)1, "The tournament board isn't ready yet.", 0, (Sprite)null, false);
				}
			}
			else if (EnsureBuilt())
			{
				_root.SetActive(true);
				IsOpen = true;
				Cursor.lockState = (CursorLockMode)0;
				Cursor.visible = true;
				LeaderboardSync.RequestAdminStatus();
				LeaderboardSync.RequestTournament();
				LeaderboardSync.RequestInvites();
				Rebuild(player);
			}
		}

		private void Close()
		{
			IsOpen = false;
			if ((Object)(object)_root != (Object)null)
			{
				_root.SetActive(false);
			}
		}

		private void Update()
		{
			if (!IsOpen)
			{
				return;
			}
			if (Input.GetKeyDown((KeyCode)27))
			{
				Close();
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null) && StateSignature(localPlayer) != _lastSig)
			{
				Rebuild(localPlayer);
			}
		}

		private bool EnsureBuilt()
		{
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Expected O, but got Unknown
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_root != (Object)null && ((Object)(object)_textSource == (Object)null || (Object)(object)_buttonSource == (Object)null))
			{
				Object.Destroy((Object)(object)_root);
				_root = null;
				_buttons.Clear();
				_status = null;
				_lastSig = null;
			}
			if ((Object)(object)_root != (Object)null)
			{
				return true;
			}
			try
			{
				if ((Object)(object)InventoryGui.instance == (Object)null)
				{
					return false;
				}
				_textSource = InventoryGui.instance.m_containerWeight;
				_buttonSource = InventoryGui.instance.m_takeAllButton;
				if ((Object)(object)_textSource == (Object)null || (Object)(object)_buttonSource == (Object)null)
				{
					return false;
				}
				_root = new GameObject("LSII_TournamentPanel");
				Canvas obj = _root.AddComponent<Canvas>();
				obj.renderMode = (RenderMode)0;
				obj.sortingOrder = 5000;
				CanvasScaler obj2 = _root.AddComponent<CanvasScaler>();
				obj2.uiScaleMode = (ScaleMode)1;
				obj2.referenceResolution = new Vector2(1920f, 1080f);
				_root.AddComponent<GraphicRaycaster>();
				Object.DontDestroyOnLoad((Object)(object)_root);
				GameObject val = NewImage(_root.transform, new Color(0.05f, 0.05f, 0.06f, 0.92f));
				RectTransform component = val.GetComponent<RectTransform>();
				Vector2 anchorMin = (component.anchorMax = new Vector2(0.5f, 0.5f));
				component.anchorMin = anchorMin;
				component.pivot = new Vector2(0.5f, 0.5f);
				component.sizeDelta = new Vector2(860f, 940f);
				_status = CloneText(val.transform, new Vector2(0f, 446f), new Vector2(820f, 940f));
				RectTransform component2 = ((Component)_status).GetComponent<RectTransform>();
				component2.pivot = new Vector2(0.5f, 1f);
				component2.anchoredPosition = new Vector2(0f, 446f);
				_status.alignment = (TextAlignmentOptions)257;
				_status.fontSize = 16f;
				_status.richText = true;
				return true;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[tourney-ui] Could not build the tournament panel: " + ex.Message));
				if ((Object)(object)_root != (Object)null)
				{
					Object.Destroy((Object)(object)_root);
				}
				_root = null;
				_status = null;
				_buttons.Clear();
				return false;
			}
		}

		private static GameObject NewImage(Transform parent, Color color)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			GameObject val = new GameObject("Panel", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			((Graphic)val.AddComponent<Image>()).color = color;
			return val;
		}

		private TMP_Text CloneText(Transform parent, Vector2 anchoredPos, Vector2 size)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = Object.Instantiate<GameObject>(((Component)_textSource).gameObject, parent);
			((Object)obj).name = "Text";
			RectTransform component = obj.GetComponent<RectTransform>();
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(0.5f, 0.5f);
			component.anchorMax = val;
			component.anchorMin = val;
			component.pivot = new Vector2(0.5f, 0.5f);
			component.anchoredPosition = anchoredPos;
			component.sizeDelta = size;
			TMP_Text component2 = obj.GetComponent<TMP_Text>();
			component2.enableAutoSizing = false;
			obj.SetActive(true);
			return component2;
		}

		private GameObject AddButton(string label, Vector2 anchoredPos, Action onClick, Vector2? size = null)
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Expected O, but got Unknown
			if ((Object)(object)_buttonSource == (Object)null || (Object)(object)_root == (Object)null)
			{
				return null;
			}
			GameObject val = Object.Instantiate<GameObject>(((Component)_buttonSource).gameObject, _root.transform.GetChild(0));
			((Object)val).name = "Btn_" + label;
			RectTransform component = val.GetComponent<RectTransform>();
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(0.5f, 0.5f);
			component.anchorMax = val2;
			component.anchorMin = val2;
			component.pivot = new Vector2(0.5f, 0.5f);
			component.anchoredPosition = anchoredPos;
			component.sizeDelta = (Vector2)(((??)size) ?? new Vector2(250f, 40f));
			TMP_Text componentInChildren = val.GetComponentInChildren<TMP_Text>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				componentInChildren.text = label;
				componentInChildren.enableAutoSizing = false;
				componentInChildren.fontSize = 15f;
			}
			Button component2 = val.GetComponent<Button>();
			if ((Object)(object)component2 != (Object)null)
			{
				((UnityEventBase)component2.onClick).RemoveAllListeners();
				((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
				{
					onClick();
				});
				((Selectable)component2).interactable = true;
			}
			val.SetActive(true);
			_buttons.Add(val);
			return val;
		}

		private string StateSignature(Player player)
		{
			long me = (((Object)(object)player != (Object)null) ? player.GetPlayerID() : 0);
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(_slotIndex).Append('|').Append(LeaderboardSync.LocalIsAdmin);
			foreach (TournamentState item in TournamentService.All)
			{
				stringBuilder.Append('#').Append(item.key).Append(item.mode)
					.Append(item.phase)
					.Append(item.entrants.Count)
					.Append(item.currentRound)
					.Append(item.championLabel)
					.Append(item.entrants.Any((TournamentEntrant e) => e.ownerId == me));
				foreach (TournamentMatch match in item.matches)
				{
					if (match.round == item.currentRound)
					{
						stringBuilder.Append(match.aReady ? '1' : '0').Append(match.bReady ? '1' : '0').Append(match.activated ? 'A' : '-');
					}
				}
			}
			foreach (DuelInvite item2 in DuelInviteService.All)
			{
				stringBuilder.Append('@').Append(item2.id).Append(item2.phase)
					.Append(item2.hostReady ? '1' : '0')
					.Append(item2.oppReady ? '1' : '0');
			}
			return stringBuilder.ToString();
		}

		private static string SlotTitle(string key)
		{
			if (key == "coins")
			{
				return "Coin Tournament";
			}
			if (key == "valcoin")
			{
				return "Valcoin Tournament";
			}
			return "Server Tournament (free)";
		}

		private static WagerCurrency SlotCurrency(string key)
		{
			if (key == "coins")
			{
				return WagerCurrency.Coins;
			}
			if (key == "valcoin")
			{
				return WagerCurrency.Valcoin;
			}
			return WagerCurrency.None;
		}

		private void Rebuild(Player player)
		{
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Unknown result type (might be due to invalid IL or missing references)
			//IL_0330: Unknown result type (might be due to invalid IL or missing references)
			//IL_0341: Unknown result type (might be due to invalid IL or missing references)
			//IL_0365: Unknown result type (might be due to invalid IL or missing references)
			//IL_0376: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_0295: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_030c: Unknown result type (might be due to invalid IL or missing references)
			//IL_048a: Unknown result type (might be due to invalid IL or missing references)
			//IL_049b: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0427: Unknown result type (might be due to invalid IL or missing references)
			//IL_0439: Unknown result type (might be due to invalid IL or missing references)
			//IL_05dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0678: Unknown result type (might be due to invalid IL or missing references)
			//IL_0689: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_06bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_098b: Unknown result type (might be due to invalid IL or missing references)
			//IL_099c: Unknown result type (might be due to invalid IL or missing references)
			//IL_075e: Unknown result type (might be due to invalid IL or missing references)
			//IL_076f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0729: Unknown result type (might be due to invalid IL or missing references)
			//IL_073a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0884: Unknown result type (might be due to invalid IL or missing references)
			//IL_0895: Unknown result type (might be due to invalid IL or missing references)
			//IL_084f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0860: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_093b: Unknown result type (might be due to invalid IL or missing references)
			//IL_094d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_root == (Object)null || (Object)(object)_status == (Object)null)
			{
				return;
			}
			_lastSig = StateSignature(player);
			foreach (GameObject button in _buttons)
			{
				if ((Object)(object)button != (Object)null)
				{
					Object.Destroy((Object)(object)button);
				}
			}
			_buttons.Clear();
			_status.text = StatusText(player);
			_status.ForceMeshUpdate(false, false);
			float num = Mathf.Clamp(446f - _status.preferredHeight - 22f, -230f, 406f);
			bool flag = LeaderboardSync.LocalIsAdmin || ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.LocalPlayerIsAdminOrHost());
			string slot = CurrentSlot;
			WagerCurrency currency = SlotCurrency(slot);
			TournamentState tournamentState = TournamentService.Get(slot);
			bool flag2 = tournamentState?.active ?? false;
			bool flag3 = flag2 && tournamentState.phase == "registration";
			bool flag4 = flag2 && tournamentState.phase == "running";
			long me = (((Object)(object)player != (Object)null) ? player.GetPlayerID() : 0);
			bool flag5 = flag2 && tournamentState.entrants.Any((TournamentEntrant e) => e.ownerId == me);
			Vector2 value = default(Vector2);
			((Vector2)(ref value))..ctor(340f, 38f);
			float num2 = num;
			AddButton("< " + SlotTitle(slot) + " >", new Vector2(-206f, num2), delegate
			{
				_slotIndex = (_slotIndex + 1) % Slots.Length;
				Rebuild(player);
			}, value);
			num2 -= 44f;
			if (!flag2 && currency != WagerCurrency.None)
			{
				int num3 = Wager.TournamentFee(currency);
				AddButton($"Start ({num3} {Wager.Display(currency)})", new Vector2(-206f, num2), delegate
				{
					StartWagered(player, currency);
				}, value);
				num2 -= 44f;
			}
			if (flag3)
			{
				if (flag5)
				{
					AddButton("Withdraw (refunds stake)", new Vector2(-206f, num2), delegate
					{
						LeaderboardSync.SendTournamentWithdraw(slot);
					}, value);
				}
				else
				{
					AddButton("Lock Totem -> Enter", new Vector2(-206f, num2), delegate
					{
						LockTotem(player, slot);
					}, value);
				}
				num2 -= 44f;
			}
			if (flag4 && flag5 && HasPendingMatch(tournamentState, me))
			{
				AddButton("Ready to Fight", new Vector2(-206f, num2), delegate
				{
					LeaderboardSync.SendTournamentReady(slot);
				}, value);
				num2 -= 44f;
			}
			AddButton("View Bracket", new Vector2(-206f, num2), delegate
			{
				Close();
				TournamentBoard.Open(player);
			}, value);
			num2 -= 44f;
			AddButton("Close", new Vector2(-206f, num2), Close, value);
			Vector2 value2 = default(Vector2);
			((Vector2)(ref value2))..ctor(350f, 36f);
			Vector2 value3 = default(Vector2);
			((Vector2)(ref value3))..ctor(350f, 30f);
			float num4 = num;
			DuelInvite mine = DuelInviteService.MineIn(me);
			if (mine == null)
			{
				WagerCurrency[] array = new WagerCurrency[2]
				{
					WagerCurrency.Coins,
					WagerCurrency.Valcoin
				};
				foreach (WagerCurrency wagerCurrency in array)
				{
					WagerCurrency cc = wagerCurrency;
					AddButton($"Post Duel Invite ({Wager.DuelStake(cc)} {Wager.Display(cc)})", new Vector2(206f, num4), delegate
					{
						PostInvite(player, cc);
					}, value2);
					num4 -= 40f;
				}
			}
			else
			{
				if (mine.phase == "matched")
				{
					AddButton("Ready to Fight (duel)", new Vector2(206f, num4), delegate
					{
						InviteAction("ready", mine.id);
					}, value2);
					num4 -= 40f;
				}
				if (mine.phase != "running")
				{
					AddButton("Withdraw Invite", new Vector2(206f, num4), delegate
					{
						InviteAction("withdraw", mine.id);
					}, value2);
					num4 -= 40f;
				}
			}
			foreach (DuelInvite item in (from i in DuelInviteService.All
				where i.phase == "open" && i.hostId != me
				orderby i.createdTicks descending
				select i).Take((mine == null) ? 4 : 2))
			{
				if (!Fits(num4))
				{
					break;
				}
				string id = item.id;
				WagerCurrency c = Wager.Parse(item.currency);
				AddButton($"Accept {Trim(item.hostName)} - {item.stake} {Wager.Display(c)}", new Vector2(206f, num4), delegate
				{
					AcceptInvite(player, id);
				}, value3);
				num4 -= 34f;
			}
			if (!flag)
			{
				return;
			}
			num4 -= 10f;
			if (!flag2)
			{
				if (currency == WagerCurrency.None)
				{
					string pendingType = EliminationTypes[_pendingTypeIndex];
					AddButton("Type: " + DisplayType(pendingType), new Vector2(206f, num4), delegate
					{
						_pendingTypeIndex = (_pendingTypeIndex + 1) % EliminationTypes.Length;
						Rebuild(player);
					}, value3);
					num4 -= 34f;
					AddButton("Admin: Start 1v1", new Vector2(206f, num4), delegate
					{
						Admin("start|1v1|0|" + pendingType);
					}, value3);
					num4 -= 34f;
					AddButton("Admin: Start Party", new Vector2(206f, num4), delegate
					{
						Admin("start|party|0|" + pendingType);
					}, value3);
					num4 -= 34f;
				}
				return;
			}
			if (flag3)
			{
				if (currency == WagerCurrency.None)
				{
					AddButton("Admin: Begin Bracket", new Vector2(206f, num4), delegate
					{
						Admin("begin|" + slot);
					}, value3);
					num4 -= 34f;
				}
				AddButton("Admin: Cancel (refund all)", new Vector2(206f, num4), delegate
				{
					Admin("cancel|" + slot);
				}, value3);
				num4 -= 34f;
				{
					foreach (TournamentEntrant item2 in tournamentState.entrants.Take(4))
					{
						if (!Fits(num4))
						{
							break;
						}
						string name = item2.label;
						AddButton("Release: " + Trim(name), new Vector2(206f, num4), delegate
						{
							Admin("release|" + name + "|" + slot);
						}, value3);
						num4 -= 32f;
					}
					return;
				}
			}
			if (flag4)
			{
				if (currency == WagerCurrency.None)
				{
					AddButton("Admin: Activate Round", new Vector2(206f, num4), delegate
					{
						Admin("activate|" + slot);
					}, value3);
					num4 -= 34f;
				}
				AddButton("Admin: Cancel", new Vector2(206f, num4), delegate
				{
					Admin("cancel|" + slot);
				}, value3);
				num4 -= 34f;
				{
					foreach (TournamentEntrant item3 in tournamentState.entrants.Where((TournamentEntrant e) => !e.eliminated).Take(3))
					{
						if (!Fits(num4))
						{
							break;
						}
						string name2 = item3.ownerName;
						string label = item3.label;
						AddButton("Forfeit: " + Trim(label), new Vector2(206f, num4), delegate
						{
							Admin("forfeit|" + name2 + "|" + slot);
						}, value3);
						num4 -= 32f;
					}
					return;
				}
			}
			AddButton("Admin: Clear (return totems)", new Vector2(206f, num4), delegate
			{
				Admin("cancel|" + slot);
			}, value3);
			static bool Fits(float yy)
			{
				return yy - 20f > -458f;
			}
		}

		private static bool HasPendingMatch(TournamentState s, long ownerId)
		{
			TournamentEntrant ent = s.entrants.FirstOrDefault((TournamentEntrant e) => e.ownerId == ownerId);
			if (ent == null)
			{
				return false;
			}
			return s.matches.Any((TournamentMatch m) => m.round == s.currentRound && string.IsNullOrEmpty(m.winnerId) && !m.activated && !string.IsNullOrEmpty(m.bId) && (m.aId == ent.entrantId || m.bId == ent.entrantId));
		}

		private static void Admin(string cmd)
		{
			LeaderboardSync.SendAdminCommand(cmd);
		}

		private static string Trim(string s)
		{
			if (string.IsNullOrEmpty(s))
			{
				return "?";
			}
			if (s.Length > 14)
			{
				return s.Substring(0, 13) + "...";
			}
			return s;
		}

		private string StatusText(Player player)
		{
			string currentSlot = CurrentSlot;
			WagerCurrency wagerCurrency = SlotCurrency(currentSlot);
			TournamentState s = TournamentService.Get(currentSlot);
			long me = (((Object)(object)player != (Object)null) ? player.GetPlayerID() : 0);
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("<size=125%><color=#FFD24A>Dvergr Tournaments & Duels</color></size>\n");
			stringBuilder.Append("<color=#AAAAAA>Viewing:</color> <color=#FFFFFF>" + SlotTitle(currentSlot) + "</color>\n\n");
			if (s == null || !s.active)
			{
				if (wagerCurrency == WagerCurrency.None)
				{
					stringBuilder.Append("<color=#CCCCCC>No free tournament is running.</color> <color=#AAAAAA>An admin can start one from the controls at right.</color>\n\n");
				}
				else
				{
					int num = Wager.TournamentFee(wagerCurrency);
					int num2 = Wager.TournamentPrize(wagerCurrency);
					int num3 = Mathf.Max(2, Plugin.WageredBracketSize.Value);
					stringBuilder.Append("<color=#CCCCCC>No " + Wager.Display(wagerCurrency) + " tournament is running — <color=#FFFFFF>any player can open one.</color></color>\n");
					stringBuilder.Append($"<color=#AAAAAA>Cost to open: <color=#B8F5B0>{num} {Wager.Display(wagerCurrency)}</color> — this also pays your own entry, you are never charged twice. ");
					stringBuilder.Append($"Fixed <color=#FFFFFF>{num3}-player</color> single-elimination bracket; every other entrant pays <color=#B8F5B0>{num}</color>. ");
					stringBuilder.Append($"The champion wins <color=#B8F5B0>{num2} {Wager.Display(wagerCurrency)}</color>. ");
					stringBuilder.Append("One Coin tournament and one Valcoin tournament may run at a time.</color>\n\n");
					string text = WagerService.ClientHint(wagerCurrency);
					if (!string.IsNullOrEmpty(text))
					{
						stringBuilder.Append("<color=#E06666>" + text + "</color>\n\n");
					}
				}
				stringBuilder.Append(HowItWorks());
				stringBuilder.Append('\n').Append(InviteSummary(me));
				return stringBuilder.ToString();
			}
			string text2 = ((s.mode == "party") ? "Party" : "1v1");
			string text3 = DisplayType(s.eliminationType);
			stringBuilder.Append("Mode: <color=#FFFFFF>" + text2 + "</color>   Type: <color=#FFFFFF>" + text3 + "</color>   Phase: <color=#FFFFFF>" + s.phase + "</color>\n");
			stringBuilder.Append(string.Format("Entrants: <color=#FFFFFF>{0}{1}</color>", s.entrants.Count, (s.size > 0) ? ("/" + s.size) : ""));
			if (s.entryFee > 0)
			{
				stringBuilder.Append($"   Entry: <color=#B8F5B0>{s.entryFee} {Wager.Display(wagerCurrency)}</color>   Purse: <color=#B8F5B0>{s.prize}</color>");
			}
			stringBuilder.Append('\n');
			if (s.entryFee > 0 && !string.IsNullOrEmpty(s.hostName))
			{
				stringBuilder.Append("<color=#AAAAAA>Opened by " + s.hostName + "</color>\n");
			}
			stringBuilder.Append('\n');
			TournamentEntrant tournamentEntrant = s.entrants.FirstOrDefault((TournamentEntrant e) => e.ownerId == me);
			if (tournamentEntrant != null)
			{
				stringBuilder.Append("<color=#B8F5B0>You are entered as '" + tournamentEntrant.label + "'.</color>\n");
			}
			else if (s.phase == "registration")
			{
				stringBuilder.Append("<color=#AAAAAA>Lock a companion's Communion Totem to enter. (Seal one at an Incinerator, or in the field with a Dead Raiser.)</color>\n");
			}
			if (s.phase == "registration")
			{
				foreach (TournamentEntrant item in s.entrants.Take(8))
				{
					string text4 = ((item.level > 0) ? $" — <color=#FFD24A>Lv{item.level}</color>" : "");
					stringBuilder.Append("  - " + item.label + " <color=#AAAAAA>(" + item.ownerName + ")</color>" + text4 + "\n");
				}
				if (s.entryFee > 0)
				{
					stringBuilder.Append($"<color=#AAAAAA>The bracket begins automatically at {s.size}/{s.size}. If it never fills it is cancelled and every stake and totem is returned.</color>\n");
				}
			}
			else if (s.phase == "running")
			{
				stringBuilder.Append($"<color=#FFFFFF>Round {s.currentRound}</color>\n");
				foreach (TournamentMatch item2 in s.matches.Where((TournamentMatch m) => m.round == s.currentRound))
				{
					if (string.IsNullOrEmpty(item2.bId))
					{
						stringBuilder.Append("  - " + item2.aLabel + " — bye\n");
						continue;
					}
					string text5 = ((!string.IsNullOrEmpty(item2.winnerId)) ? ("<color=#B8F5B0>" + ((item2.winnerId == item2.aId) ? item2.aLabel : item2.bLabel) + " won</color>") : (item2.activated ? "<color=#E06666>fighting</color>" : ("<color=#AAAAAA>ready: " + (item2.aReady ? "yes" : "no") + " / " + (item2.bReady ? "yes" : "no") + "</color>")));
					stringBuilder.Append("  - " + item2.aLabel + " vs " + item2.bLabel + " — " + text5 + "\n");
				}
				stringBuilder.Append("<color=#AAAAAA>You and your opponent choose the venue: meet anywhere, then BOTH press Ready to Fight. Your companions are summoned there at full health and fight automatically.</color>\n");
			}
			else if (s.phase == "complete")
			{
				stringBuilder.Append("<color=#FFD24A>Champion: " + s.championLabel + "</color>\n");
			}
			stringBuilder.Append('\n').Append(InviteSummary(me));
			return stringBuilder.ToString();
		}

		private static string HowItWorks()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("<color=#FFD24A>How a tournament runs</color>\n<color=#CCCCCC>");
			stringBuilder.Append("1. Anyone opens one by paying the stake.\n");
			stringBuilder.Append("2. Entrants lock a companion's Communion Totem in; it is held safely until the event ends.\n");
			stringBuilder.Append("3. The bracket starts by itself once it is full. Pairings are seeded by ladder rating.\n");
			stringBuilder.Append("4. <color=#FFFFFF>You pick where each duel happens.</color> Meet your opponent anywhere you both like, then BOTH press Ready to Fight. Your two companions are summoned beside you at full health, locked onto each other, and fight until one is subdued — no other companion can join in.\n");
			stringBuilder.Append("5. The winner advances; both companions are resealed into their totems with any XP they gained.\n");
			stringBuilder.Append("6. Lose, and your totem comes back to you when the event ends.</color>\n");
			return stringBuilder.ToString();
		}

		private static string InviteSummary(long me)
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("<color=#FFD24A>Duel invites</color> ");
			stringBuilder.Append("<color=#AAAAAA>— stake on a single duel instead. Post one, anyone may accept by matching the stake, and the winner takes both. ");
			stringBuilder.Append("You may only be in one invite at a time. The two of you choose where to fight, exactly as above.</color>\n");
			DuelInvite duelInvite = DuelInviteService.MineIn(me);
			if (duelInvite != null)
			{
				string text = Wager.Display(Wager.Parse(duelInvite.currency));
				string text2 = ((duelInvite.phase == "open") ? "waiting for a challenger" : ((duelInvite.phase == "matched") ? (duelInvite.oppName + " accepted — ready: " + (duelInvite.hostReady ? "yes" : "no") + " / " + (duelInvite.oppReady ? "yes" : "no")) : ((duelInvite.phase == "running") ? "the duel is under way" : "settled")));
				stringBuilder.Append($"<color=#B8F5B0>Your invite: {duelInvite.stake} {text}, winner takes {duelInvite.stake * 2} — {text2}.</color>\n");
			}
			int num = DuelInviteService.All.Count((DuelInvite i) => i.phase == "open" && i.hostId != me);
			if (num > 0)
			{
				stringBuilder.Append($"<color=#8FE3FF>{num} open invite(s) you can accept — see the buttons at right.</color>\n");
			}
			return stringBuilder.ToString();
		}

		private static bool TakeStake(Player player, WagerCurrency currency, int amount, out int paid)
		{
			paid = 0;
			if (currency != WagerCurrency.Coins || amount <= 0)
			{
				return true;
			}
			if (!Wager.TryTakeCoins(player, amount))
			{
				Msg($"You need {amount} Coins for that ({Wager.CoinsHeld(player)} held).");
				return false;
			}
			paid = amount;
			return true;
		}

		private void StartWagered(Player player, WagerCurrency currency)
		{
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			if (!Plugin.WagersEnabled.Value)
			{
				Msg("Wagered events are disabled on this server.");
				return;
			}
			int amount = Wager.TournamentFee(currency);
			if (TakeStake(player, currency, amount, out var paid))
			{
				LeaderboardSync.SendStartWagered(Wager.Key(currency), paid);
				Msg("Opening a " + Wager.Display(currency) + " tournament...");
			}
		}

		private static bool PickTotem(Player player, out ItemData totem, out string id, out string label, out int caste, out int level)
		{
			totem = null;
			id = null;
			label = null;
			caste = 0;
			level = 0;
			Inventory val = (((Object)(object)player != (Object)null) ? ((Humanoid)player).GetInventory() : null);
			if (val == null)
			{
				return false;
			}
			totem = ((IEnumerable<ItemData>)val.GetAllItems()).FirstOrDefault((Func<ItemData, bool>)TotemConversionService.IsCompanionTotem);
			if (totem == null)
			{
				Msg("You have no companion totem. Seal a companion first — at an Incinerator, or in the field with a Dead Raiser.");
				return false;
			}
			id = TotemConversionService.CompanionIdOf(totem);
			if (string.IsNullOrEmpty(id))
			{
				Msg("That totem has no ladder identity and can't be staked.");
				return false;
			}
			label = TotemConversionService.LabelOf(totem);
			caste = (int)TotemConversionService.CasteOf(totem);
			level = TotemConversionService.LevelOf(totem);
			return true;
		}

		private void LockTotem(Player player, string slot)
		{
			TournamentState tournamentState = TournamentService.Get(slot);
			if (tournamentState == null || !tournamentState.active || tournamentState.phase != "registration")
			{
				Msg("Registration isn't open.");
			}
			else
			{
				if ((Object)(object)player == (Object)null)
				{
					return;
				}
				Inventory inventory = ((Humanoid)player).GetInventory();
				long playerID = player.GetPlayerID();
				string playerName = player.GetPlayerName();
				WagerCurrency currency = Wager.Parse(tournamentState.currency);
				int amount = ((playerID != tournamentState.hostId || tournamentState.hostCredit <= 0) ? tournamentState.entryFee : 0);
				ItemData totem;
				string id;
				string label2;
				int caste;
				int level;
				int paid2;
				if (tournamentState.mode == "party")
				{
					List<ItemData> list = inventory.GetAllItems().Where(TotemConversionService.IsCompanionTotem).ToList();
					if (list.Count == 0)
					{
						Msg("You have no companion totem to enter. Seal a companion first.");
						return;
					}
					int count = Mathf.Max(1, Plugin.MaxPartySize.Value);
					List<ItemData> list2 = list.Take(count).ToList();
					if (!TakeStake(player, currency, amount, out var paid))
					{
						return;
					}
					List<string> payloads = list2.Select(TotemConversionService.SerializePayload).ToList();
					string text = LeaderboardStore.FindParty(playerID)?.partyName;
					string label = (string.IsNullOrEmpty(text) ? playerName : text);
					int seedRating = LeaderboardStore.FindParty(playerID)?.rating ?? 1000;
					foreach (ItemData item2 in list2)
					{
						inventory.RemoveItem(item2);
					}
					LeaderboardSync.SendTournamentJoinEscrow(slot, playerID.ToString(), playerID, playerName, label, -1, seedRating, payloads, 0, paid);
					Msg($"Locked {list2.Count} totem(s) — entering your party...");
				}
				else if (PickTotem(player, out totem, out id, out label2, out caste, out level) && TakeStake(player, currency, amount, out paid2))
				{
					int seedRating2 = LeaderboardStore.Find(id)?.rating ?? 1000;
					string item = TotemConversionService.SerializePayload(totem);
					inventory.RemoveItem(totem);
					LeaderboardSync.SendTournamentJoinEscrow(slot, id, playerID, playerName, label2, caste, seedRating2, new List<string> { item }, level, paid2);
					Msg("Locked '" + label2 + "' into a slot — entering...");
				}
			}
		}

		private void PostInvite(Player player, WagerCurrency currency)
		{
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			ItemData totem;
			string id;
			string label;
			int caste;
			int level;
			if (!Plugin.WagersEnabled.Value)
			{
				Msg("Wagered events are disabled on this server.");
			}
			else if (DuelInviteService.MineIn(player.GetPlayerID()) != null)
			{
				Msg("You already have a duel invite — withdraw it first.");
			}
			else if (PickTotem(player, out totem, out id, out label, out caste, out level))
			{
				int amount = Wager.DuelStake(currency);
				if (TakeStake(player, currency, amount, out var paid))
				{
					string payload = TotemConversionService.SerializePayload(totem);
					((Humanoid)player).GetInventory().RemoveItem(totem);
					LeaderboardSync.SendInviteAction("post", null, Wager.Key(currency), id, label, level, caste, payload, paid);
					Msg("Posting a duel invite with '" + label + "'...");
				}
			}
		}

		private void AcceptInvite(Player player, string inviteId)
		{
			DuelInvite duelInvite = DuelInviteService.All.FirstOrDefault((DuelInvite i) => i.id == inviteId);
			ItemData totem;
			string id;
			string label;
			int caste;
			int level;
			if (duelInvite == null || duelInvite.phase != "open")
			{
				Msg("That invite is no longer open.");
			}
			else if (PickTotem(player, out totem, out id, out label, out caste, out level))
			{
				WagerCurrency currency = Wager.Parse(duelInvite.currency);
				if (TakeStake(player, currency, duelInvite.stake, out var paid))
				{
					string payload = TotemConversionService.SerializePayload(totem);
					((Humanoid)player).GetInventory().RemoveItem(totem);
					LeaderboardSync.SendInviteAction("accept", inviteId, duelInvite.currency, id, label, level, caste, payload, paid);
					Msg("Accepting " + duelInvite.hostName + "'s challenge with '" + label + "'...");
				}
			}
		}

		private static void InviteAction(string action, string inviteId)
		{
			LeaderboardSync.SendInviteAction(action, inviteId, null, null, null, 0, 0, null, 0);
		}

		private static void Msg(string m)
		{
			if ((Object)(object)MessageHud.instance != (Object)null)
			{
				MessageHud.instance.ShowMessage((MessageType)1, m, 0, (Sprite)null, false);
			}
		}
	}
}
namespace LostScrollsII.Patches
{
	[HarmonyPatch(typeof(Terminal), "InitTerminal")]
	public static class AdminCommands
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static ConsoleEvent <>9__1_0;

			public static ConsoleOptionsFetcher <>9__1_1;

			public static ConsoleEvent <>9__1_2;

			public static ConsoleOptionsFetcher <>9__1_3;

			public static ConsoleEvent <>9__1_4;

			public static ConsoleEvent <>9__1_5;

			public static ConsoleEvent <>9__1_6;

			public static ConsoleOptionsFetcher <>9__1_7;

			public static ConsoleEvent <>9__1_8;

			public static ConsoleOptionsFetcher <>9__1_9;

			public static ConsoleEvent <>9__1_10;

			public static ConsoleEvent <>9__1_11;

			public static ConsoleEvent <>9__1_12;

			public static ConsoleEvent <>9__1_13;

			public static ConsoleEvent <>9__1_14;

			public static ConsoleEvent <>9__1_15;

			public static ConsoleEvent <>9__1_16;

			public static ConsoleEvent <>9__1_17;

			public static ConsoleEvent <>9__1_18;

			public static ConsoleEvent <>9__1_19;

			public static ConsoleEvent <>9__1_20;

			public static ConsoleEvent <>9__1_21;

			public static ConsoleEvent <>9__1_22;

			internal void <Postfix>b__1_0(ConsoleEventArgs args)
			{
				//IL_0096: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer == (Object)null)
				{
					args.Context.AddString("No local player.");
					return;
				}
				if (args.Length < 2)
				{
					args.Context.AddString("Usage: de_spawn <rogue|fire|ice|support> [level]");
					return;
				}
				if (!TryParseCaste(args[1], out var caste))
				{
					args.Context.AddString("Unknown caste '" + args[1] + "'. Use rogue|fire|ice|support.");
					return;
				}
				int result = 1;
				if (args.Length >= 3)
				{
					int.TryParse(args[2], out result);
				}
				result = Mathf.Clamp(result, 1, 10);
				Vector3 pos = ((Component)localPlayer).transform.position + ((Component)localPlayer).transform.forward * 2f + Vector3.up * 0.5f;
				GameObject val = CommunionService.SpawnRecruited(caste, result, localPlayer, pos);
				args.Context.AddString(((Object)(object)val != (Object)null) ? $"Spawned {caste} companion (level {result})." : "Spawn failed — creature prefab not found.");
			}

			internal List<string> <Postfix>b__1_1()
			{
				return new List<string> { "rogue", "fire", "ice", "support" };
			}

			internal void <Postfix>b__1_2(ConsoleEventArgs args)
			{
				int num = -1;
				int num2 = 10;
				for (int i = 1; i < args.Length; i++)
				{
					int result;
					if (TryParseCaste(args[i], out var caste))
					{
						num = (int)caste;
					}
					else if (int.TryParse(args[i], out result))
					{
						num2 = Mathf.Clamp(result, 1, 100);
					}
				}
				List<CompanionRecord> list = LeaderboardStore.Ranked(num);
				if (list.Count == 0)
				{
					args.Context.AddString("Duel ladder is empty.");
					return;
				}
				args.Context.AddString("=== Dvergr Duel Ladder" + ((num >= 0) ? (" (" + ((DvergrCaste)num).Display() + ")") : "") + " ===");
				for (int j = 0; j < list.Count && j < num2; j++)
				{
					CompanionRecord companionRecord = list[j];
					string text = (string.IsNullOrEmpty(companionRecord.companionName) ? "(unnamed)" : companionRecord.companionName);
					string text2 = (string.IsNullOrEmpty(companionRecord.ownerName) ? "?" : companionRecord.ownerName);
					args.Context.AddString($"#{j + 1,-2} {companionRecord.rating,5}  {text} ({text2})  {companionRecord.wins}W/{companionRecord.losses}L");
				}
			}

			internal List<string> <Postfix>b__1_3()
			{
				return new List<string> { "rogue", "fire", "ice", "support" };
			}

			internal void <Postfix>b__1_4(ConsoleEventArgs args)
			{
				int num = 10;
				if (args.Length >= 2 && int.TryParse(args[1], out var result))
				{
					num = Mathf.Clamp(result, 1, 100);
				}
				List<PartyRecord> list = LeaderboardStore.RankedParties();
				if (list.Count == 0)
				{
					args.Context.AddString("Party ladder is empty.");
					return;
				}
				args.Context.AddString("=== Dvergr Party Duel Ladder ===");
				for (int i = 0; i < list.Count && i < num; i++)
				{
					PartyRecord partyRecord = list[i];
					string text = (string.IsNullOrEmpty(partyRecord.ownerName) ? "?" : partyRecord.ownerName);
					string text2 = (string.IsNullOrEmpty(partyRecord.partyName) ? text : (partyRecord.partyName + " (" + text + ")"));
					int num2 = ((partyRecord.memberSnapshot != null) ? partyRecord.memberSnapshot.Count : 0);
					args.Context.AddString($"#{i + 1,-2} {partyRecord.rating,5}  {text2}  {partyRecord.wins}W/{partyRecord.losses}L  (team {num2})");
				}
			}

			internal void <Postfix>b__1_5(ConsoleEventArgs args)
			{
				if ((Object)(object)Player.m_localPlayer == (Object)null)
				{
					args.Context.AddString("No local player.");
					return;
				}
				if (args.Length < 2)
				{
					args.Context.AddString("Usage: de_party_name <name>");
					return;
				}
				string text = string.Join(" ", args.Args, 1, args.Length - 1).Trim();
				if (text.Length > 32)
				{
					text = text.Substring(0, 32);
				}
				LeaderboardSync.SendPartyName(text);
				args.Context.AddString("Your party is now named '" + text + "'.");
			}

			internal void <Postfix>b__1_6(ConsoleEventArgs args)
			{
				<>c__DisplayClass1_0 <>c__DisplayClass1_ = default(<>c__DisplayClass1_0);
				<>c__DisplayClass1_.args = args;
				Player localPlayer = Player.m_localPlayer;
				switch ((<>c__DisplayClass1_.args.Length >= 2) ? <>c__DisplayClass1_.args[1].ToLowerInvariant() : "")
				{
				case "start":
				{
					string arg = ((<>c__DisplayClass1_.args.Length >= 3) ? <>c__DisplayClass1_.args[2] : "1v1");
					int result = 0;
					if (<>c__DisplayClass1_.args.Length >= 4)
					{
						int.TryParse(<>c__DisplayClass1_.args[3], out result);
					}
					string arg2 = ((<>c__DisplayClass1_.args.Length >= 5) ? <>c__DisplayClass1_.args[4] : "single");
					LeaderboardSync.SendAdminCommand($"start|{arg}|{result}|{arg2}");
					break;
				}
				case "open":
				{
					if ((Object)(object)localPlayer == (Object)null)
					{
						<>c__DisplayClass1_.args.Context.AddString("No local player.");
						break;
					}
					if (<>c__DisplayClass1_.args.Length < 3)
					{
						<>c__DisplayClass1_.args.Context.AddString("Usage: de_tournament open <coins|valcoin>");
						break;
					}
					WagerCurrency wagerCurrency = Wager.Parse(<>c__DisplayClass1_.args[2]);
					if (wagerCurrency == WagerCurrency.None)
					{
						<>c__DisplayClass1_.args.Context.AddString("Currency must be coins or valcoin.");
						break;
					}
					int num = Wager.TournamentFee(wagerCurrency);
					int clientPaidCoins = 0;
					if (wagerCurrency == WagerCurrency.Coins)
					{
						if (!Wager.TryTakeCoins(localPlayer, num))
						{
							<>c__DisplayClass1_.args.Context.AddString($"You need {num} Coins to open that.");
							break;
						}
						clientPaidCoins = num;
					}
					LeaderboardSync.SendStartWagered(Wager.Key(wagerCurrency), clientPaidCoins);
					<>c__DisplayClass1_.args.Context.AddString("Opening a " + Wager.Display(wagerCurrency) + " tournament...");
					break;
				}
				case "begin":
					LeaderboardSync.SendAdminCommand("begin|" + <Postfix>g__SlotAt|1_23(2, ref <>c__DisplayClass1_));
					break;
				case "cancel":
					LeaderboardSync.SendAdminCommand("cancel|" + <Postfix>g__SlotAt|1_23(2, ref <>c__DisplayClass1_));
					break;
				case "forfeit":
					if (<>c__DisplayClass1_.args.Length < 3)
					{
						<>c__DisplayClass1_.args.Context.AddString("Usage: de_tournament forfeit <playerName> [slot]");
					}
					else
					{
						LeaderboardSync.SendAdminCommand("forfeit|" + <>c__DisplayClass1_.args[2] + "|" + <Postfix>g__SlotAt|1_23(3, ref <>c__DisplayClass1_));
					}
					break;
				case "join":
					if ((Object)(object)localPlayer == (Object)null)
					{
						<>c__DisplayClass1_.args.Context.AddString("No local player.");
					}
					else
					{
						JoinTournament(localPlayer, <>c__DisplayClass1_.args, <Postfix>g__SlotAt|1_23(2, ref <>c__DisplayClass1_));
					}
					break;
				case "ready":
					if ((Object)(object)localPlayer == (Object)null)
					{
						<>c__DisplayClass1_.args.Context.AddString("No local player.");
					}
					else
					{
						LeaderboardSync.SendTournamentReady(<Postfix>g__SlotAt|1_23(2, ref <>c__DisplayClass1_));
					}
					break;
				case "withdraw":
					if ((Object)(object)localPlayer == (Object)null)
					{
						<>c__DisplayClass1_.args.Context.AddString("No local player.");
						break;
					}
					LeaderboardSync.SendTournamentWithdraw(<Postfix>g__SlotAt|1_23(2, ref <>c__DisplayClass1_));
					<>c__DisplayClass1_.args.Context.AddString("Withdrawing your entry...");
					break;
				case "release":
					if (<>c__DisplayClass1_.args.Length < 3)
					{
						<>c__DisplayClass1_.args.Context.AddString("Usage: de_tournament release <entrant name> [slot]");
					}
					else
					{
						LeaderboardSync.SendAdminCommand("release|" + <>c__DisplayClass1_.args[2] + "|" + <Postfix>g__SlotAt|1_23(3, ref <>c__DisplayClass1_));
					}
					break;
				case "activate":
					LeaderboardSync.SendAdminCommand("activate|" + <Postfix>g__SlotAt|1_23(2, ref <>c__DisplayClass1_));
					break;
				case "bracket":
					PrintBracket(<>c__DisplayClass1_.args);
					break;
				default:
					<>c__DisplayClass1_.args.Context.AddString("Usage: de_tournament <open coins|valcoin | join [slot] | ready [slot] | withdraw [slot] | bracket | start 1v1|party [size] [single|double|round_robin] | begin [slot] | activate [slot] | forfeit <name> [slot] | release <name> [slot] | cancel [slot]>");
					break;
				}
			}

			internal List<string> <Postfix>b__1_7()
			{
				return new List<string>
				{
					"open", "join", "ready", "withdraw", "bracket", "start", "begin", "activate", "forfeit", "release",
					"cancel"
				};
			}

			internal void <Postfix>b__1_8(ConsoleEventArgs args)
			{
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer == (Object)null)
				{
					args.Context.AddString("No local player.");
					return;
				}
				string text = ((args.Length >= 2) ? args[1].ToLowerInvariant() : "list");
				long playerID = localPlayer.GetPlayerID();
				switch (text)
				{
				case "post":
				{
					if (args.Length < 3)
					{
						args.Context.AddString("Usage: de_duel_invite post <coins|valcoin>");
						return;
					}
					WagerCurrency wagerCurrency = Wager.Parse(args[2]);
					if (wagerCurrency == WagerCurrency.None)
					{
						args.Context.AddString("Currency must be coins or valcoin.");
					}
					else
					{
						PostInviteFromConsole(localPlayer, wagerCurrency, args);
					}
					return;
				}
				case "accept":
				{
					<>c__DisplayClass1_1 CS$<>8__locals3 = new <>c__DisplayClass1_1();
					if (args.Length < 3)
					{
						args.Context.AddString("Usage: de_duel_invite accept <posting player>");
						return;
					}
					CS$<>8__locals3.target = string.Join(" ", args.Args, 2, args.Length - 2);
					DuelInvite duelInvite3 = DuelInviteService.All.FirstOrDefault((DuelInvite i) => i.phase == "open" && string.Equals(i.hostName, CS$<>8__locals3.target, StringComparison.OrdinalIgnoreCase));
					if (duelInvite3 == null)
					{
						args.Context.AddString("No open invite from '" + CS$<>8__locals3.target + "'.");
					}
					else
					{
						AcceptInviteFromConsole(localPlayer, duelInvite3, args);
					}
					return;
				}
				case "ready":
				{
					DuelInvite duelInvite = DuelInviteService.MineIn(playerID);
					if (duelInvite == null)
					{
						args.Context.AddString("You have no duel invite.");
					}
					else
					{
						LeaderboardSync.SendInviteAction("ready", duelInvite.id, null, null, null, 0, 0, null, 0);
					}
					return;
				}
				case "withdraw":
				{
					DuelInvite duelInvite2 = DuelInviteService.MineIn(playerID);
					if (duelInvite2 == null)
					{
						args.Context.AddString("You have no duel invite.");
					}
					else
					{
						LeaderboardSync.SendInviteAction("withdraw", duelInvite2.id, null, null, null, 0, 0, null, 0);
					}
					return;
				}
				}
				List<DuelInvite> list = DuelInviteService.All.ToList();
				if (list.Count == 0)
				{
					args.Context.AddString("No duel invites posted.");
					return;
				}
				args.Context.AddString("=== Duel invites ===");
				foreach (DuelInvite item in list)
				{
					string text2 = Wager.Display(Wager.Parse(item.currency));
					args.Context.AddString($"  {item.hostName} - {item.hostLabel} (Lv{item.hostLevel}) - {item.stake} {text2} " + "[" + item.phase + "]" + ((item.phase == "matched") ? (" vs " + item.oppName) : ""));
				}
			}

			internal List<string> <Postfix>b__1_9()
			{
				return new List<string> { "post", "accept", "ready", "withdraw", "list" };
			}

			internal void <Postfix>b__1_10(ConsoleEventArgs args)
			{
				List<ChampionRecord> list = TournamentService.LoadChampions();
				if (list.Count == 0)
				{
					args.Context.AddString("No champions recorded yet.");
					return;
				}
				args.Context.AddString("=== Hall of Champions ===");
				int num = list.Count - 1;
				while (num >= 0 && num >= list.Count - 20)
				{
					ChampionRecord championRecord = list[num];
					args.Context.AddString($"[{championRecord.mode}] {championRecord.championLabel} ({championRecord.ownerName}) — bracket of {championRecord.bracketSize}");
					num--;
				}
			}

			internal void <Postfix>b__1_11(ConsoleEventArgs args)
			{
				LeaderboardSync.SendAdminCommand("season");
				args.Context.AddString("Duel season reset requested.");
			}

			internal void <Postfix>b__1_12(ConsoleEventArgs args)
			{
				if (ContainerPanelPositioner.BiomeLordsLoaded())
				{
					args.Context.AddString("BiomeLords owns the chest UI position — use its own setting.");
				}
				else if (Plugin.ContainerPanelOffset != null)
				{
					Plugin.ContainerPanelOffset.Value = "auto";
					args.Context.AddString("Chest/storage UI position reset to default.");
				}
			}

			internal void <Postfix>b__1_13(ConsoleEventArgs args)
			{
				if (BountyFeatureGate.IsServerAuthority)
				{
					args.Context.AddString("Bounty hunting: " + (BountyFeatureGate.IsEnabled ? "ACTIVE" : "inactive") + " (this is the server/host).");
					args.Context.AddString($"  BiomeLords : {BountyFeatureGate.BiomeLordsLoaded}");
					args.Context.AddString($"  ServerGuide: {BountyFeatureGate.ServerGuideLoaded}");
					args.Context.AddString($"  Donations  : {BountyFeatureGate.DonationsLoaded}");
					args.Context.AddString($"  Config     : {Plugin.BountyEnabled == null || Plugin.BountyEnabled.Value}");
				}
				else
				{
					args.Context.AddString("Bounty hunting: " + (BountySync.FeatureActive ? "ACTIVE on this server" : "not available on this server") + ".");
					args.Context.AddString("  (Reported by the server — it needs BiomeLords, ServerGuide and Valheim Donations.)");
				}
			}

			internal void <Postfix>b__1_14(ConsoleEventArgs args)
			{
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
				//IL_0111: Unknown result type (might be due to invalid IL or missing references)
				//IL_011b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0120: Unknown result type (might be due to invalid IL or missing references)
				//IL_012c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0133: Unknown result type (might be due to invalid IL or missing references)
				//IL_0155: Unknown result type (might be due to invalid IL or missing references)
				//IL_0161: Unknown result type (might be due to invalid IL or missing references)
				//IL_017a: Unknown result type (might be due to invalid IL or missing references)
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer == (Object)null)
				{
					args.Context.AddString("No local player.");
					return;
				}
				int result = 5;
				if (args.Length >= 2)
				{
					int.TryParse(args[1], out result);
				}
				result = Mathf.Clamp(result, 1, 25);
				List<(Vector3, Biome)> list = new List<(Vector3, Biome)>();
				string report;
				int num = BountyLocationSampler.SampleMany(Vector3.zero, Plugin.BountySearchMinRadius.Value, Plugin.BountySearchMaxRadius.Value, result, list, out report);
				args.Context.AddString($"Sampled {num}/{result} bounty location(s):");
				string[] array = report.Split(new char[1] { '\n' });
				foreach (string text in array)
				{
					if (!string.IsNullOrEmpty(text.Trim()))
					{
						args.Context.AddString(text);
					}
				}
				for (int j = 0; j < list.Count; j++)
				{
					(Vector3, Biome) tuple = list[j];
					Vector3 item = tuple.Item1;
					Biome item2 = tuple.Item2;
					float num2 = Vector3.Distance(new Vector3(((Component)localPlayer).transform.position.x, 0f, ((Component)localPlayer).transform.position.z), new Vector3(item.x, 0f, item.z));
					BountyMapPin.Show($"test_{j}", $"Test bounty ({item2})", item);
					args.Context.AddString($"  pinned #{j}: {item2}, {num2:F0}m from you.");
				}
				if (num > 0)
				{
					args.Context.AddString("Use de_bounty_sample_clear to remove the test pins.");
				}
			}

			internal void <Postfix>b__1_15(ConsoleEventArgs args)
			{
				//IL_0103: Unknown result type (might be due to invalid IL or missing references)
				//IL_010e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0118: Unknown result type (might be due to invalid IL or missing references)
				//IL_011d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0122: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_0135: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
				//IL_015c: Unknown result type (might be due to invalid IL or missing references)
				//IL_015d: Unknown result type (might be due to invalid IL or missing references)
				//IL_018c: Unknown result type (might be due to invalid IL or missing references)
				//IL_018d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0162: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer == (Object)null)
				{
					args.Context.AddString("No local player.");
					return;
				}
				int result = 1;
				if (args.Length >= 2)
				{
					int.TryParse(args[1], out result);
				}
				result = BountyTiers.Clamp(result);
				Vector3 pos;
				Biome biome;
				if (args.Length >= 3 && args[2].ToLowerInvariant() == "far")
				{
					if (!BountyLocationSampler.TrySample(Vector3.zero, Plugin.BountySearchMinRadius.Value, Plugin.BountySearchMaxRadius.Value, out pos, out biome, out var stats))
					{
						args.Context.AddString("No valid location: " + stats);
						return;
					}
					args.Context.AddString($"Sampled {biome} at ({pos.x:F0}, {pos.z:F0}) — {stats}");
					args.Context.AddString("NOTE: that zone is probably not loaded, so nothing will spawn there until you travel to it.");
				}
				else
				{
					pos = ((Component)localPlayer).transform.position + ((Component)localPlayer).transform.forward * 12f;
					float y = default(float);
					if ((Object)(object)ZoneSystem.instance != (Object)null && ZoneSystem.instance.GetSolidHeight(pos, ref y, 1000))
					{
						pos.y = y;
					}
					biome = (Biome)((WorldGenerator.instance != null) ? ((int)WorldGenerator.instance.GetBiome(pos)) : 0);
				}
				string text = "test_" + Guid.NewGuid().ToString("N").Substring(0, 8);
				BountySpawner.SpawnedBounty spawnedBounty = BountySpawner.Spawn(text, result, pos, biome);
				if (spawnedBounty == null)
				{
					args.Context.AddString("Spawn failed — see the log.");
					return;
				}
				BountyMapPin.Show(text, $"{BountyTiers.TierName(result)} bounty ({biome})", pos);
				args.Context.AddString($"Spawned {BountyTiers.Describe(result)} in {biome}.");
				Character val = (((Object)(object)spawnedBounty.Target != (Object)null) ? spawnedBounty.Target.GetComponent<Character>() : null);
				if ((Object)(object)val != (Object)null)
				{
					args.Context.AddString($"  target: {val.m_name}, {val.GetMaxHealth():F0} HP, level {val.GetLevel()}.");
				}
				args.Context.AddString($"  escort: {spawnedBounty.Minions.Count}. Bounty id '{text}'.");
			}

			internal void <Postfix>b__1_16(ConsoleEventArgs args)
			{
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer == (Object)null)
				{
					args.Context.AddString("No local player.");
					return;
				}
				int num = BountyService.BestCompetitiveRank(localPlayer);
				args.Context.AddString((num > 0) ? $"Best duel/party standing: #{num} (bonus reaches to #{Plugin.BountyValcoinRankDepth.Value})." : "You are unranked on both ladders — no rank bonus applies.");
				for (int i = 1; i <= 5; i++)
				{
					float num2 = BountyService.ValcoinChanceFor(localPlayer, i);
					args.Context.AddString($"  tier {i} ({BountyTiers.TierName(i)}): {num2 * 100f:F0}% chance of a Valcoin payout.");
				}
				if (!BountyFeatureGate.DonationsLoaded)
				{
					args.Context.AddString("NOTE: Valheim Donations is not loaded — no coins would actually be paid.");
				}
			}

			internal void <Postfix>b__1_17(ConsoleEventArgs args)
			{
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer == (Object)null)
				{
					args.Context.AddString("No local player.");
					return;
				}
				if (BountyQuestGate.IsUnlocked(localPlayer))
				{
					args.Context.AddString("The board is already open to you.");
					return;
				}
				((Humanoid)localPlayer).AddUniqueKey("LS_BountyStart");
				args.Context.AddString("Commission granted — the posting will be marked shortly.");
			}

			internal void <Postfix>b__1_18(ConsoleEventArgs args)
			{
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer == (Object)null)
				{
					args.Context.AddString("No local player.");
					return;
				}
				BountyQuestGate.Reset(localPlayer);
				args.Context.AddString("Bounty quest reset — the board is locked again. (ServerGuide's own once-per-player record of the conversation is separate; use its reset if you want Haldor to offer it again.)");
			}

			internal void <Postfix>b__1_19(ConsoleEventArgs args)
			{
				//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
				List<BountyPosting> list = BountyBoardStore.All();
				if (list.Count == 0)
				{
					args.Context.AddString(BountyFeatureGate.AvailableToLocalPlayer ? "The board is empty right now." : "Bounty hunting isn't active on this server.");
					return;
				}
				Player localPlayer = Player.m_localPlayer;
				args.Context.AddString($"Wanted Board ({list.Count} posting(s)):");
				foreach (BountyPosting item in list)
				{
					string text = (item.IsOpen ? "open" : ("taken by " + item.acceptedByName));
					string text2 = (((Object)(object)localPlayer != (Object)null) ? $"{Vector3.Distance(new Vector3(((Component)localPlayer).transform.position.x, 0f, ((Component)localPlayer).transform.position.z), new Vector3(item.x, 0f, item.z)):F0}m" : "?");
					string text3 = (item.spawned ? ", spawned" : "") + (item.tutorial ? ", commission" : "") + (BountyBoardStore.IsElite(item) ? ", ELITE" : "");
					string text4 = ((item.postedTicks > 0) ? $", {(DateTime.UtcNow - new DateTime(item.postedTicks)).TotalHours:F1}h old" : "");
					args.Context.AddString("  " + item.Label + " — " + text2 + ", " + text + text3 + text4);
				}
				float value = Plugin.BountyRefreshHours.Value;
				args.Context.AddString((value > 0f) ? $"Unclaimed postings are retired after {value:F0}h." : "Board rotation is disabled (RefreshHours = 0).");
			}

			internal void <Postfix>b__1_20(ConsoleEventArgs args)
			{
				int result = 10;
				if (args.Length >= 2)
				{
					int.TryParse(args[1], out result);
				}
				result = Mathf.Clamp(result, 1, 50);
				List<BountyHunterRecord> list = BountyLeaderboardStore.Ranked();
				if (list.Count == 0)
				{
					args.Context.AddString("No bounties have been answered yet.");
					return;
				}
				args.Context.AddString("Bounty hunters — points (felled/freed, best posting):");
				for (int i = 0; i < list.Count && i < result; i++)
				{
					BountyHunterRecord bountyHunterRecord = list[i];
					string arg = ((bountyHunterRecord.bestTier > 0) ? BountyTiers.TierName(bountyHunterRecord.bestTier) : "-");
					args.Context.AddString($"  #{i + 1,-2} {bountyHunterRecord.points,5}  {bountyHunterRecord.ownerName}  " + $"({bountyHunterRecord.kills} felled / {bountyHunterRecord.communes} freed, best: {arg})");
				}
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer != (Object)null)
				{
					int num = BountyLeaderboardStore.RankOf(localPlayer.GetPlayerID());
					int value = Plugin.BountyLeaderboardBonusRank.Value;
					if (num > 0)
					{
						args.Context.AddString($"You are #{num}." + ((value > 0 && num <= value) ? " Your standing earns +1 reward tier." : ((value > 0) ? $" Reach #{value} for +1 reward tier." : "")));
					}
				}
			}

			internal void <Postfix>b__1_21(ConsoleEventArgs args)
			{
				LeaderboardSync.SendAdminCommand("bountyseason");
				args.Context.AddString("Bounty season reset requested.");
			}

			internal void <Postfix>b__1_22(ConsoleEventArgs args)
			{
				int count = BountyMapPin.Count;
				BountyMapPin.ClearAll();
				args.Context.AddString($"Cleared {count} bounty pin(s).");
			}
		}

		[StructLayout(LayoutKind.Auto)]
		[CompilerGenerated]
		private struct <>c__DisplayClass1_0
		{
			public ConsoleEventArgs args;
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass1_1
		{
			public string target;

			internal bool <Postfix>b__24(DuelInvite i)
			{
				if (i.phase == "open")
				{
					return string.Equals(i.hostName, target, StringComparison.OrdinalIgnoreCase);
				}
				return false;
			}
		}

		private static bool _registered;

		public static void Postfix()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Expected O, but got Unknown
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Expected O, but got Unknown
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Expected O, but got Unknown
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Expected O, but got Unknown
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Expected O, but got Unknown
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Expected O, but got Unknown
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Expected O, but got Unknown
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Expected O, but got Unknown
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Expected O, but got Unknown
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Expected O, but got Unknown
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Expected O, but got Unknown
			//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b7: Expected O, but got Unknown
			//IL_02f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ef: Expected O, but got Unknown
			//IL_0330: Unknown result type (might be due to invalid IL or missing references)
			//IL_031c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0321: Unknown result type (might be due to invalid IL or missing references)
			//IL_0327: Expected O, but got Unknown
			//IL_0368: Unknown result type (might be due to invalid IL or missing references)
			//IL_0354: Unknown result type (might be due to invalid IL or missing references)
			//IL_0359: Unknown result type (might be due to invalid IL or missing references)
			//IL_035f: Expected O, but got Unknown
			//IL_03a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_038c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0391: Unknown result type (might be due to invalid IL or missing references)
			//IL_0397: Expected O, but got Unknown
			//IL_03d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cf: Expected O, but got Unknown
			//IL_0410: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0401: Unknown result type (might be due to invalid IL or missing references)
			//IL_0407: Expected O, but got Unknown
			//IL_0448: Unknown result type (might be due to invalid IL or missing references)
			//IL_0434: Unknown result type (might be due to invalid IL or missing references)
			//IL_0439: Unknown result type (might be due to invalid IL or missing references)
			//IL_043f: Expected O, but got Unknown
			//IL_0480: Unknown result type (might be due to invalid IL or missing references)
			//IL_046c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0471: Unknown result type (might be due to invalid IL or missing references)
			//IL_0477: Expected O, but got Unknown
			//IL_04b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04af: Expected O, but got Unknown
			if (_registered)
			{
				return;
			}
			_registered = true;
			object obj = <>c.<>9__1_0;
			if (obj == null)
			{
				ConsoleEvent val = delegate(ConsoleEventArgs args)
				{
					//IL_0096: Unknown result type (might be due to invalid IL or missing references)
					//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
					//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
					//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
					//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
					//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
					//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
					//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
					//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
					Player localPlayer = Player.m_localPlayer;
					DvergrCaste caste;
					if ((Object)(object)localPlayer == (Object)null)
					{
						args.Context.AddString("No local player.");
					}
					else if (args.Length < 2)
					{
						args.Context.AddString("Usage: de_spawn <rogue|fire|ice|support> [level]");
					}
					else if (!TryParseCaste(args[1], out caste))
					{
						args.Context.AddString("Unknown caste '" + args[1] + "'. Use rogue|fire|ice|support.");
					}
					else
					{
						int result = 1;
						if (args.Length >= 3)
						{
							int.TryParse(args[2], out result);
						}
						result = Mathf.Clamp(result, 1, 10);
						Vector3 pos = ((Component)localPlayer).transform.position + ((Component)localPlayer).transform.forward * 2f + Vector3.up * 0.5f;
						GameObject val30 = CommunionService.SpawnRecruited(caste, result, localPlayer, pos);
						args.Context.AddString(((Object)(object)val30 != (Object)null) ? $"Spawned {caste} companion (level {result})." : "Spawn failed — creature prefab not found.");
					}
				};
				<>c.<>9__1_0 = val;
				obj = (object)val;
			}
			ConsoleEvent val2 = (ConsoleEvent)obj;
			object obj2 = <>c.<>9__1_1;
			if (obj2 == null)
			{
				ConsoleOptionsFetcher val3 = () => new List<string> { "rogue", "fire", "ice", "support" };
				<>c.<>9__1_1 = val3;
				obj2 = (object)val3;
			}
			new ConsoleCommand("de_spawn", "<rogue|fire|ice|support> [level] - spawn a recruited Dvergr companion", val2, false, false, false, false, false, (ConsoleOptionsFetcher)obj2, false, false, false);
			object obj3 = <>c.<>9__1_2;
			if (obj3 == null)
			{
				ConsoleEvent val4 = delegate(ConsoleEventArgs args)
				{
					int num = -1;
					int num2 = 10;
					for (int i = 1; i < args.Length; i++)
					{
						int result;
						if (TryParseCaste(args[i], out var caste))
						{
							num = (int)caste;
						}
						else if (int.TryParse(args[i], out result))
						{
							num2 = Mathf.Clamp(result, 1, 100);
						}
					}
					List<CompanionRecord> list = LeaderboardStore.Ranked(num);
					if (list.Count == 0)
					{
						args.Context.AddString("Duel ladder is empty.");
					}
					else
					{
						args.Context.AddString("=== Dvergr Duel Ladder" + ((num >= 0) ? (" (" + ((DvergrCaste)num).Display() + ")") : "") + " ===");
						for (int j = 0; j < list.Count && j < num2; j++)
						{
							CompanionRecord companionRecord = list[j];
							string text = (string.IsNullOrEmpty(companionRecord.companionName) ? "(unnamed)" : companionRecord.companionName);
							string text2 = (string.IsNullOrEmpty(companionRecord.ownerName) ? "?" : companionRecord.ownerName);
							args.Context.AddString($"#{j + 1,-2} {companionRecord.rating,5}  {text} ({text2})  {companionRecord.wins}W/{companionRecord.losses}L");
						}
					}
				};
				<>c.<>9__1_2 = val4;
				obj3 = (object)val4;
			}
			ConsoleEvent val5 = (ConsoleEvent)obj3;
			object obj4 = <>c.<>9__1_3;
			if (obj4 == null)
			{
				ConsoleOptionsFetcher val6 = () => new List<string> { "rogue", "fire", "ice", "support" };
				<>c.<>9__1_3 = val6;
				obj4 = (object)val6;
			}
			new ConsoleCommand("de_ladder", "[rogue|fire|ice|support] [count] - show the Dvergr duel ladder", val5, false, false, false, false, false, (ConsoleOptionsFetcher)obj4, false, false, false);
			object obj5 = <>c.<>9__1_4;
			if (obj5 == null)
			{
				ConsoleEvent val7 = delegate(ConsoleEventArgs args)
				{
					int num = 10;
					if (args.Length >= 2 && int.TryParse(args[1], out var result))
					{
						num = Mathf.Clamp(result, 1, 100);
					}
					List<PartyRecord> list = LeaderboardStore.RankedParties();
					if (list.Count == 0)
					{
						args.Context.AddString("Party ladder is empty.");
					}
					else
					{
						args.Context.AddString("=== Dvergr Party Duel Ladder ===");
						for (int i = 0; i < list.Count && i < num; i++)
						{
							PartyRecord partyRecord = list[i];
							string text = (string.IsNullOrEmpty(partyRecord.ownerName) ? "?" : partyRecord.ownerName);
							string text2 = (string.IsNullOrEmpty(partyRecord.partyName) ? text : (partyRecord.partyName + " (" + text + ")"));
							int num2 = ((partyRecord.memberSnapshot != null) ? partyRecord.memberSnapshot.Count : 0);
							args.Context.AddString($"#{i + 1,-2} {partyRecord.rating,5}  {text2}  {partyRecord.wins}W/{partyRecord.losses}L  (team {num2})");
						}
					}
				};
				<>c.<>9__1_4 = val7;
				obj5 = (object)val7;
			}
			ConsoleEvent val8 = (ConsoleEvent)obj5;
			new ConsoleCommand("de_party_ladder", "[count] - show the Dvergr party duel ladder", val8, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj6 = <>c.<>9__1_5;
			if (obj6 == null)
			{
				ConsoleEvent val9 = delegate(ConsoleEventArgs args)
				{
					if ((Object)(object)Player.m_localPlayer == (Object)null)
					{
						args.Context.AddString("No local player.");
					}
					else if (args.Length < 2)
					{
						args.Context.AddString("Usage: de_party_name <name>");
					}
					else
					{
						string text = string.Join(" ", args.Args, 1, args.Length - 1).Trim();
						if (text.Length > 32)
						{
							text = text.Substring(0, 32);
						}
						LeaderboardSync.SendPartyName(text);
						args.Context.AddString("Your party is now named '" + text + "'.");
					}
				};
				<>c.<>9__1_5 = val9;
				obj6 = (object)val9;
			}
			new ConsoleCommand("de_party_name", "<name> - name your party of companions", (ConsoleEvent)obj6, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj7 = <>c.<>9__1_6;
			if (obj7 == null)
			{
				ConsoleEvent val10 = delegate(ConsoleEventArgs args)
				{
					Player localPlayer = Player.m_localPlayer;
					switch ((args.Length >= 2) ? args[1].ToLowerInvariant() : "")
					{
					case "start":
					{
						string arg = ((args.Length >= 3) ? args[2] : "1v1");
						int result = 0;
						if (args.Length >= 4)
						{
							int.TryParse(args[3], out result);
						}
						string arg2 = ((args.Length >= 5) ? args[4] : "single");
						LeaderboardSync.SendAdminCommand($"start|{arg}|{result}|{arg2}");
						break;
					}
					case "open":
						if ((Object)(object)localPlayer == (Object)null)
						{
							args.Context.AddString("No local player.");
						}
						else if (args.Length < 3)
						{
							args.Context.AddString("Usage: de_tournament open <coins|valcoin>");
						}
						else
						{
							WagerCurrency wagerCurrency = Wager.Parse(args[2]);
							if (wagerCurrency == WagerCurrency.None)
							{
								args.Context.AddString("Currency must be coins or valcoin.");
							}
							else
							{
								int num = Wager.TournamentFee(wagerCurrency);
								int clientPaidCoins = 0;
								if (wagerCurrency == WagerCurrency.Coins)
								{
									if (!Wager.TryTakeCoins(localPlayer, num))
									{
										args.Context.AddString($"You need {num} Coins to open that.");
										break;
									}
									clientPaidCoins = num;
								}
								LeaderboardSync.SendStartWagered(Wager.Key(wagerCurrency), clientPaidCoins);
								args.Context.AddString("Opening a " + Wager.Display(wagerCurrency) + " tournament...");
							}
						}
						break;
					case "begin":
						LeaderboardSync.SendAdminCommand("begin|" + SlotAt(2));
						break;
					case "cancel":
						LeaderboardSync.SendAdminCommand("cancel|" + SlotAt(2));
						break;
					case "forfeit":
						if (args.Length < 3)
						{
							args.Context.AddString("Usage: de_tournament forfeit <playerName> [slot]");
						}
						else
						{
							LeaderboardSync.SendAdminCommand("forfeit|" + args[2] + "|" + SlotAt(3));
						}
						break;
					case "join":
						if ((Object)(object)localPlayer == (Object)null)
						{
							args.Context.AddString("No local player.");
						}
						else
						{
							JoinTournament(localPlayer, args, SlotAt(2));
						}
						break;
					case "ready":
						if ((Object)(object)localPlayer == (Object)null)
						{
							args.Context.AddString("No local player.");
						}
						else
						{
							LeaderboardSync.SendTournamentReady(SlotAt(2));
						}
						break;
					case "withdraw":
						if ((Object)(object)localPlayer == (Object)null)
						{
							args.Context.AddString("No local player.");
						}
						else
						{
							LeaderboardSync.SendTournamentWithdraw(SlotAt(2));
							args.Context.AddString("Withdrawing your entry...");
						}
						break;
					case "release":
						if (args.Length < 3)
						{
							args.Context.AddString("Usage: de_tournament release <entrant name> [slot]");
						}
						else
						{
							LeaderboardSync.SendAdminCommand("release|" + args[2] + "|" + SlotAt(3));
						}
						break;
					case "activate":
						LeaderboardSync.SendAdminCommand("activate|" + SlotAt(2));
						break;
					case "bracket":
						PrintBracket(args);
						break;
					default:
						args.Context.AddString("Usage: de_tournament <open coins|valcoin | join [slot] | ready [slot] | withdraw [slot] | bracket | start 1v1|party [size] [single|double|round_robin] | begin [slot] | activate [slot] | forfeit <name> [slot] | release <name> [slot] | cancel [slot]>");
						break;
					}
					string SlotAt(int index)
					{
						if (args.Length <= index)
						{
							return "";
						}
						return args[index].ToLowerInvariant();
					}
				};
				<>c.<>9__1_6 = val10;
				obj7 = (object)val10;
			}
			ConsoleEvent val11 = (ConsoleEvent)obj7;
			object obj8 = <>c.<>9__1_7;
			if (obj8 == null)
			{
				ConsoleOptionsFetcher val12 = () => new List<string>
				{
					"open", "join", "ready", "withdraw", "bracket", "start", "begin", "activate", "forfeit", "release",
					"cancel"
				};
				<>c.<>9__1_7 = val12;
				obj8 = (object)val12;
			}
			new ConsoleCommand("de_tournament", "<open|join|ready|withdraw|bracket|start|begin|activate|forfeit|release|cancel> - run or enter a companion duel tournament", val11, false, false, false, false, false, (ConsoleOptionsFetcher)obj8, false, false, false);
			object obj9 = <>c.<>9__1_8;
			if (obj9 == null)
			{
				ConsoleEvent val13 = delegate(ConsoleEventArgs args)
				{
					Player localPlayer = Player.m_localPlayer;
					if ((Object)(object)localPlayer == (Object)null)
					{
						args.Context.AddString("No local player.");
					}
					else
					{
						string text = ((args.Length >= 2) ? args[1].ToLowerInvariant() : "list");
						long playerID = localPlayer.GetPlayerID();
						switch (text)
						{
						case "post":
							if (args.Length < 3)
							{
								args.Context.AddString("Usage: de_duel_invite post <coins|valcoin>");
							}
							else
							{
								WagerCurrency wagerCurrency = Wager.Parse(args[2]);
								if (wagerCurrency == WagerCurrency.None)
								{
									args.Context.AddString("Currency must be coins or valcoin.");
								}
								else
								{
									PostInviteFromConsole(localPlayer, wagerCurrency, args);
								}
							}
							break;
						case "accept":
							if (args.Length < 3)
							{
								args.Context.AddString("Usage: de_duel_invite accept <posting player>");
							}
							else
							{
								string target = string.Join(" ", args.Args, 2, args.Length - 2);
								DuelInvite duelInvite3 = DuelInviteService.All.FirstOrDefault((DuelInvite i) => i.phase == "open" && string.Equals(i.hostName, target, StringComparison.OrdinalIgnoreCase));
								if (duelInvite3 == null)
								{
									args.Context.AddString("No open invite from '" + target + "'.");
								}
								else
								{
									AcceptInviteFromConsole(localPlayer, duelInvite3, args);
								}
							}
							break;
						case "ready":
						{
							DuelInvite duelInvite = DuelInviteService.MineIn(playerID);
							if (duelInvite == null)
							{
								args.Context.AddString("You have no duel invite.");
							}
							else
							{
								LeaderboardSync.SendInviteAction("ready", duelInvite.id, null, null, null, 0, 0, null, 0);
							}
							break;
						}
						case "withdraw":
						{
							DuelInvite duelInvite2 = DuelInviteService.MineIn(playerID);
							if (duelInvite2 == null)
							{
								args.Context.AddString("You have no duel invite.");
							}
							else
							{
								LeaderboardSync.SendInviteAction("withdraw", duelInvite2.id, null, null, null, 0, 0, null, 0);
							}
							break;
						}
						default:
						{
							List<DuelInvite> list = DuelInviteService.All.ToList();
							if (list.Count != 0)
							{
								args.Context.AddString("=== Duel invites ===");
								{
									foreach (DuelInvite item3 in list)
									{
										string text2 = Wager.Display(Wager.Parse(item3.currency));
										args.Context.AddString($"  {item3.hostName} - {item3.hostLabel} (Lv{item3.hostLevel}) - {item3.stake} {text2} " + "[" + item3.phase + "]" + ((item3.phase == "matched") ? (" vs " + item3.oppName) : ""));
									}
									break;
								}
							}
							args.Context.AddString("No duel invites posted.");
							break;
						}
						}
					}
				};
				<>c.<>9__1_8 = val13;
				obj9 = (object)val13;
			}
			ConsoleEvent val14 = (ConsoleEvent)obj9;
			object obj10 = <>c.<>9__1_9;
			if (obj10 == null)
			{
				ConsoleOptionsFetcher val15 = () => new List<string> { "post", "accept", "ready", "withdraw", "list" };
				<>c.<>9__1_9 = val15;
				obj10 = (object)val15;
			}
			new ConsoleCommand("de_duel_invite", "<post coins|valcoin | accept <player> | ready | withdraw | list> - stake a companion on a single duel", val14, false, false, false, false, false, (ConsoleOptionsFetcher)obj10, false, false, false);
			object obj11 = <>c.<>9__1_10;
			if (obj11 == null)
			{
				ConsoleEvent val16 = delegate(ConsoleEventArgs args)
				{
					List<ChampionRecord> list = TournamentService.LoadChampions();
					if (list.Count == 0)
					{
						args.Context.AddString("No champions recorded yet.");
					}
					else
					{
						args.Context.AddString("=== Hall of Champions ===");
						int num = list.Count - 1;
						while (num >= 0 && num >= list.Count - 20)
						{
							ChampionRecord championRecord = list[num];
							args.Context.AddString($"[{championRecord.mode}] {championRecord.championLabel} ({championRecord.ownerName}) — bracket of {championRecord.bracketSize}");
							num--;
						}
					}
				};
				<>c.<>9__1_10 = val16;
				obj11 = (object)val16;
			}
			new ConsoleCommand("de_champions", "- list past tournament champions", (ConsoleEvent)obj11, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj12 = <>c.<>9__1_11;
			if (obj12 == null)
			{
				ConsoleEvent val17 = delegate(ConsoleEventArgs args)
				{
					LeaderboardSync.SendAdminCommand("season");
					args.Context.AddString("Duel season reset requested.");
				};
				<>c.<>9__1_11 = val17;
				obj12 = (object)val17;
			}
			ConsoleEvent val18 = (ConsoleEvent)obj12;
			new ConsoleCommand("de_season_reset", "- archive the duel ladder and start a new season (admin)", val18, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, true);
			object obj13 = <>c.<>9__1_12;
			if (obj13 == null)
			{
				ConsoleEvent val19 = delegate(ConsoleEventArgs args)
				{
					if (ContainerPanelPositioner.BiomeLordsLoaded())
					{
						args.Context.AddString("BiomeLords owns the chest UI position — use its own setting.");
					}
					else if (Plugin.ContainerPanelOffset != null)
					{
						Plugin.ContainerPanelOffset.Value = "auto";
						args.Context.AddString("Chest/storage UI position reset to default.");
					}
				};
				<>c.<>9__1_12 = val19;
				obj13 = (object)val19;
			}
			new ConsoleCommand("de_container_reset", "- move the chest/storage UI back to its default position", (ConsoleEvent)obj13, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj14 = <>c.<>9__1_13;
			if (obj14 == null)
			{
				ConsoleEvent val20 = delegate(ConsoleEventArgs args)
				{
					if (BountyFeatureGate.IsServerAuthority)
					{
						args.Context.AddString("Bounty hunting: " + (BountyFeatureGate.IsEnabled ? "ACTIVE" : "inactive") + " (this is the server/host).");
						args.Context.AddString($"  BiomeLords : {BountyFeatureGate.BiomeLordsLoaded}");
						args.Context.AddString($"  ServerGuide: {BountyFeatureGate.ServerGuideLoaded}");
						args.Context.AddString($"  Donations  : {BountyFeatureGate.DonationsLoaded}");
						args.Context.AddString($"  Config     : {Plugin.BountyEnabled == null || Plugin.BountyEnabled.Value}");
					}
					else
					{
						args.Context.AddString("Bounty hunting: " + (BountySync.FeatureActive ? "ACTIVE on this server" : "not available on this server") + ".");
						args.Context.AddString("  (Reported by the server — it needs BiomeLords, ServerGuide and Valheim Donations.)");
					}
				};
				<>c.<>9__1_13 = val20;
				obj14 = (object)val20;
			}
			new ConsoleCommand("de_bounty_status", "- show whether bounty hunting is active, and why", (ConsoleEvent)obj14, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj15 = <>c.<>9__1_14;
			if (obj15 == null)
			{
				ConsoleEvent val21 = delegate(ConsoleEventArgs args)
				{
					//IL_004a: Unknown result type (might be due to invalid IL or missing references)
					//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
					//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
					//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
					//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
					//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
					//IL_0111: Unknown result type (might be due to invalid IL or missing references)
					//IL_011b: Unknown result type (might be due to invalid IL or missing references)
					//IL_0120: Unknown result type (might be due to invalid IL or missing references)
					//IL_012c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0133: Unknown result type (might be due to invalid IL or missing references)
					//IL_0155: Unknown result type (might be due to invalid IL or missing references)
					//IL_0161: Unknown result type (might be due to invalid IL or missing references)
					//IL_017a: Unknown result type (might be due to invalid IL or missing references)
					Player localPlayer = Player.m_localPlayer;
					if ((Object)(object)localPlayer == (Object)null)
					{
						args.Context.AddString("No local player.");
					}
					else
					{
						int result = 5;
						if (args.Length >= 2)
						{
							int.TryParse(args[1], out result);
						}
						result = Mathf.Clamp(result, 1, 25);
						List<(Vector3, Biome)> list = new List<(Vector3, Biome)>();
						string report;
						int num = BountyLocationSampler.SampleMany(Vector3.zero, Plugin.BountySearchMinRadius.Value, Plugin.BountySearchMaxRadius.Value, result, list, out report);
						args.Context.AddString($"Sampled {num}/{result} bounty location(s):");
						string[] array = report.Split(new char[1] { '\n' });
						foreach (string text in array)
						{
							if (!string.IsNullOrEmpty(text.Trim()))
							{
								args.Context.AddString(text);
							}
						}
						for (int j = 0; j < list.Count; j++)
						{
							(Vector3, Biome) tuple = list[j];
							Vector3 item = tuple.Item1;
							Biome item2 = tuple.Item2;
							float num2 = Vector3.Distance(new Vector3(((Component)localPlayer).transform.position.x, 0f, ((Component)localPlayer).transform.position.z), new Vector3(item.x, 0f, item.z));
							BountyMapPin.Show($"test_{j}", $"Test bounty ({item2})", item);
							args.Context.AddString($"  pinned #{j}: {item2}, {num2:F0}m from you.");
						}
						if (num > 0)
						{
							args.Context.AddString("Use de_bounty_sample_clear to remove the test pins.");
						}
					}
				};
				<>c.<>9__1_14 = val21;
				obj15 = (object)val21;
			}
			new ConsoleCommand("de_bounty_sample", "[count] - roll candidate bounty locations and pin them (test tool)", (ConsoleEvent)obj15, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj16 = <>c.<>9__1_15;
			if (obj16 == null)
			{
				ConsoleEvent val22 = delegate(ConsoleEventArgs args)
				{
					//IL_0103: Unknown result type (might be due to invalid IL or missing references)
					//IL_010e: Unknown result type (might be due to invalid IL or missing references)
					//IL_0118: Unknown result type (might be due to invalid IL or missing references)
					//IL_011d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0122: Unknown result type (might be due to invalid IL or missing references)
					//IL_0068: Unknown result type (might be due to invalid IL or missing references)
					//IL_0135: Unknown result type (might be due to invalid IL or missing references)
					//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
					//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
					//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
					//IL_015c: Unknown result type (might be due to invalid IL or missing references)
					//IL_015d: Unknown result type (might be due to invalid IL or missing references)
					//IL_018c: Unknown result type (might be due to invalid IL or missing references)
					//IL_018d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0162: Unknown result type (might be due to invalid IL or missing references)
					//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
					//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
					//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
					Player localPlayer = Player.m_localPlayer;
					if ((Object)(object)localPlayer == (Object)null)
					{
						args.Context.AddString("No local player.");
					}
					else
					{
						int result = 1;
						if (args.Length >= 2)
						{
							int.TryParse(args[1], out result);
						}
						result = BountyTiers.Clamp(result);
						Vector3 pos;
						Biome biome;
						if (args.Length >= 3 && args[2].ToLowerInvariant() == "far")
						{
							if (!BountyLocationSampler.TrySample(Vector3.zero, Plugin.BountySearchMinRadius.Value, Plugin.BountySearchMaxRadius.Value, out pos, out biome, out var stats))
							{
								args.Context.AddString("No valid location: " + stats);
								return;
							}
							args.Context.AddString($"Sampled {biome} at ({pos.x:F0}, {pos.z:F0}) — {stats}");
							args.Context.AddString("NOTE: that zone is probably not loaded, so nothing will spawn there until you travel to it.");
						}
						else
						{
							pos = ((Component)localPlayer).transform.position + ((Component)localPlayer).transform.forward * 12f;
							float y = default(float);
							if ((Object)(object)ZoneSystem.instance != (Object)null && ZoneSystem.instance.GetSolidHeight(pos, ref y, 1000))
							{
								pos.y = y;
							}
							biome = (Biome)((WorldGenerator.instance != null) ? ((int)WorldGenerator.instance.GetBiome(pos)) : 0);
						}
						string text = "test_" + Guid.NewGuid().ToString("N").Substring(0, 8);
						BountySpawner.SpawnedBounty spawnedBounty = BountySpawner.Spawn(text, result, pos, biome);
						if (spawnedBounty == null)
						{
							args.Context.AddString("Spawn failed — see the log.");
						}
						else
						{
							BountyMapPin.Show(text, $"{BountyTiers.TierName(result)} bounty ({biome})", pos);
							args.Context.AddString($"Spawned {BountyTiers.Describe(result)} in {biome}.");
							Character val30 = (((Object)(object)spawnedBounty.Target != (Object)null) ? spawnedBounty.Target.GetComponent<Character>() : null);
							if ((Object)(object)val30 != (Object)null)
							{
								args.Context.AddString($"  target: {val30.m_name}, {val30.GetMaxHealth():F0} HP, level {val30.GetLevel()}.");
							}
							args.Context.AddString($"  escort: {spawnedBounty.Minions.Count}. Bounty id '{text}'.");
						}
					}
				};
				<>c.<>9__1_15 = val22;
				obj16 = (object)val22;
			}
			new ConsoleCommand("de_bounty_spawn", "[tier 1-5] [far] - spawn a scaled bounty target + escort (test tool)", (ConsoleEvent)obj16, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj17 = <>c.<>9__1_16;
			if (obj17 == null)
			{
				ConsoleEvent val23 = delegate(ConsoleEventArgs args)
				{
					Player localPlayer = Player.m_localPlayer;
					if ((Object)(object)localPlayer == (Object)null)
					{
						args.Context.AddString("No local player.");
					}
					else
					{
						int num = BountyService.BestCompetitiveRank(localPlayer);
						args.Context.AddString((num > 0) ? $"Best duel/party standing: #{num} (bonus reaches to #{Plugin.BountyValcoinRankDepth.Value})." : "You are unranked on both ladders — no rank bonus applies.");
						for (int i = 1; i <= 5; i++)
						{
							float num2 = BountyService.ValcoinChanceFor(localPlayer, i);
							args.Context.AddString($"  tier {i} ({BountyTiers.TierName(i)}): {num2 * 100f:F0}% chance of a Valcoin payout.");
						}
						if (!BountyFeatureGate.DonationsLoaded)
						{
							args.Context.AddString("NOTE: Valheim Donations is not loaded — no coins would actually be paid.");
						}
					}
				};
				<>c.<>9__1_16 = val23;
				obj17 = (object)val23;
			}
			new ConsoleCommand("de_bounty_chance", "- show your Valcoin payout chance per bounty tier", (ConsoleEvent)obj17, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj18 = <>c.<>9__1_17;
			if (obj18 == null)
			{
				ConsoleEvent val24 = delegate(ConsoleEventArgs args)
				{
					Player localPlayer = Player.m_localPlayer;
					if ((Object)(object)localPlayer == (Object)null)
					{
						args.Context.AddString("No local player.");
					}
					else if (BountyQuestGate.IsUnlocked(localPlayer))
					{
						args.Context.AddString("The board is already open to you.");
					}
					else
					{
						((Humanoid)localPlayer).AddUniqueKey("LS_BountyStart");
						args.Context.AddString("Commission granted — the posting will be marked shortly.");
					}
				};
				<>c.<>9__1_17 = val24;
				obj18 = (object)val24;
			}
			new ConsoleCommand("de_bounty_commission", "- grant yourself the warden's commission (test tool)", (ConsoleEvent)obj18, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj19 = <>c.<>9__1_18;
			if (obj19 == null)
			{
				ConsoleEvent val25 = delegate(ConsoleEventArgs args)
				{
					Player localPlayer = Player.m_localPlayer;
					if ((Object)(object)localPlayer == (Object)null)
					{
						args.Context.AddString("No local player.");
					}
					else
					{
						BountyQuestGate.Reset(localPlayer);
						args.Context.AddString("Bounty quest reset — the board is locked again. (ServerGuide's own once-per-player record of the conversation is separate; use its reset if you want Haldor to offer it again.)");
					}
				};
				<>c.<>9__1_18 = val25;
				obj19 = (object)val25;
			}
			new ConsoleCommand("de_bounty_quest_reset", "- forget the warden's commission, re-locking the board (test tool)", (ConsoleEvent)obj19, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj20 = <>c.<>9__1_19;
			if (obj20 == null)
			{
				ConsoleEvent val26 = delegate(ConsoleEventArgs args)
				{
					//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
					//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
					//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
					//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
					List<BountyPosting> list = BountyBoardStore.All();
					if (list.Count == 0)
					{
						args.Context.AddString(BountyFeatureGate.AvailableToLocalPlayer ? "The board is empty right now." : "Bounty hunting isn't active on this server.");
					}
					else
					{
						Player localPlayer = Player.m_localPlayer;
						args.Context.AddString($"Wanted Board ({list.Count} posting(s)):");
						foreach (BountyPosting item4 in list)
						{
							string text = (item4.IsOpen ? "open" : ("taken by " + item4.acceptedByName));
							string text2 = (((Object)(object)localPlayer != (Object)null) ? $"{Vector3.Distance(new Vector3(((Component)localPlayer).transform.position.x, 0f, ((Component)localPlayer).transform.position.z), new Vector3(item4.x, 0f, item4.z)):F0}m" : "?");
							string text3 = (item4.spawned ? ", spawned" : "") + (item4.tutorial ? ", commission" : "") + (BountyBoardStore.IsElite(item4) ? ", ELITE" : "");
							string text4 = ((item4.postedTicks > 0) ? $", {(DateTime.UtcNow - new DateTime(item4.postedTicks)).TotalHours:F1}h old" : "");
							args.Context.AddString("  " + item4.Label + " — " + text2 + ", " + text + text3 + text4);
						}
						float value = Plugin.BountyRefreshHours.Value;
						args.Context.AddString((value > 0f) ? $"Unclaimed postings are retired after {value:F0}h." : "Board rotation is disabled (RefreshHours = 0).");
					}
				};
				<>c.<>9__1_19 = val26;
				obj20 = (object)val26;
			}
			new ConsoleCommand("de_bounty_board", "- list the current bounty postings", (ConsoleEvent)obj20, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj21 = <>c.<>9__1_20;
			if (obj21 == null)
			{
				ConsoleEvent val27 = delegate(ConsoleEventArgs args)
				{
					int result = 10;
					if (args.Length >= 2)
					{
						int.TryParse(args[1], out result);
					}
					result = Mathf.Clamp(result, 1, 50);
					List<BountyHunterRecord> list = BountyLeaderboardStore.Ranked();
					if (list.Count == 0)
					{
						args.Context.AddString("No bounties have been answered yet.");
					}
					else
					{
						args.Context.AddString("Bounty hunters — points (felled/freed, best posting):");
						for (int i = 0; i < list.Count && i < result; i++)
						{
							BountyHunterRecord bountyHunterRecord = list[i];
							string arg = ((bountyHunterRecord.bestTier > 0) ? BountyTiers.TierName(bountyHunterRecord.bestTier) : "-");
							args.Context.AddString($"  #{i + 1,-2} {bountyHunterRecord.points,5}  {bountyHunterRecord.ownerName}  " + $"({bountyHunterRecord.kills} felled / {bountyHunterRecord.communes} freed, best: {arg})");
						}
						Player localPlayer = Player.m_localPlayer;
						if ((Object)(object)localPlayer != (Object)null)
						{
							int num = BountyLeaderboardStore.RankOf(localPlayer.GetPlayerID());
							int value = Plugin.BountyLeaderboardBonusRank.Value;
							if (num > 0)
							{
								args.Context.AddString($"You are #{num}." + ((value > 0 && num <= value) ? " Your standing earns +1 reward tier." : ((value > 0) ? $" Reach #{value} for +1 reward tier." : "")));
							}
						}
					}
				};
				<>c.<>9__1_20 = val27;
				obj21 = (object)val27;
			}
			new ConsoleCommand("de_bounty_ladder", "[count] - show the bounty hunter standings", (ConsoleEvent)obj21, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj22 = <>c.<>9__1_21;
			if (obj22 == null)
			{
				ConsoleEvent val28 = delegate(ConsoleEventArgs args)
				{
					LeaderboardSync.SendAdminCommand("bountyseason");
					args.Context.AddString("Bounty season reset requested.");
				};
				<>c.<>9__1_21 = val28;
				obj22 = (object)val28;
			}
			new ConsoleCommand("de_bounty_season_reset", "- archive the bounty ladder and start a new season (admin)", (ConsoleEvent)obj22, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, true);
			object obj23 = <>c.<>9__1_22;
			if (obj23 == null)
			{
				ConsoleEvent val29 = delegate(ConsoleEventArgs args)
				{
					int count = BountyMapPin.Count;
					BountyMapPin.ClearAll();
					args.Context.AddString($"Cleared {count} bounty pin(s).");
				};
				<>c.<>9__1_22 = val29;
				obj23 = (object)val29;
			}
			new ConsoleCommand("de_bounty_sample_clear", "- remove the pins placed by de_bounty_sample", (ConsoleEvent)obj23, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
		}

		private static void JoinTournament(Player player, ConsoleEventArgs args, string slot)
		{
			TournamentState tournamentState = TournamentService.Get(slot);
			if (tournamentState == null || !tournamentState.active || tournamentState.phase != "registration")
			{
				args.Context.AddString("No tournament is accepting entries in that slot.");
				return;
			}
			long playerID = player.GetPlayerID();
			string playerName = player.GetPlayerName();
			WagerCurrency num = Wager.Parse(tournamentState.currency);
			int num2 = ((playerID != tournamentState.hostId || tournamentState.hostCredit <= 0) ? tournamentState.entryFee : 0);
			int num3 = 0;
			if (num == WagerCurrency.Coins && num2 > 0)
			{
				if (!Wager.TryTakeCoins(player, num2))
				{
					args.Context.AddString($"You need {num2} Coins to enter.");
					return;
				}
				num3 = num2;
			}
			if (tournamentState.mode == "party")
			{
				List<DvergrCompanion> list = GatherFollowers(player, Mathf.Max(1, Plugin.MaxPartySize.Value));
				if (list.Count == 0)
				{
					if (num3 > 0)
					{
						Wager.GiveCoins(player, num3);
					}
					args.Context.AddString("No free Follow-stance allies of yours nearby to enter as a party.");
					return;
				}
				List<string> list2 = new List<string>();
				foreach (DvergrCompanion item2 in list)
				{
					ItemData val = TotemConversionService.CreateTotem(item2);
					if (val != null)
					{
						list2.Add(TotemConversionService.SerializePayload(val));
					}
				}
				foreach (DvergrCompanion item3 in list)
				{
					item3.DespawnToTotem();
				}
				PartyRecord partyRecord = LeaderboardStore.FindParty(playerID);
				int seedRating = partyRecord?.rating ?? 1000;
				string label = ((partyRecord != null && !string.IsNullOrEmpty(partyRecord.partyName)) ? partyRecord.partyName : playerName);
				LeaderboardSync.SendTournamentJoinEscrow(slot, playerID.ToString(), playerID, playerName, label, -1, seedRating, list2, 0, num3);
				args.Context.AddString($"Sealing and registering your party of {list2.Count}...");
				return;
			}
			GameObject hoverObject = ((Humanoid)player).GetHoverObject();
			Character val2 = (((Object)(object)hoverObject != (Object)null) ? hoverObject.GetComponentInParent<Character>() : null);
			DvergrCompanion dvergrCompanion = (((Object)(object)val2 != (Object)null) ? ((Component)val2).GetComponent<DvergrCompanion>() : null);
			if ((Object)(object)dvergrCompanion == (Object)null || !dvergrCompanion.IsOwner(player))
			{
				if (num3 > 0)
				{
					Wager.GiveCoins(player, num3);
				}
				args.Context.AddString(((Object)(object)dvergrCompanion == (Object)null) ? "Hover the companion you want to enter, then run de_tournament join." : "That companion isn't yours.");
				return;
			}
			string text = dvergrCompanion.EnsureCompanionId();
			int seedRating2 = LeaderboardStore.Find(text)?.rating ?? 1000;
			ItemData val3 = TotemConversionService.CreateTotem(dvergrCompanion);
			if (val3 == null)
			{
				if (num3 > 0)
				{
					Wager.GiveCoins(player, num3);
				}
				args.Context.AddString("Could not seal that companion (missing totem prefab).");
				return;
			}
			string item = TotemConversionService.SerializePayload(val3);
			string displayName = dvergrCompanion.DisplayName;
			int caste = (int)dvergrCompanion.Caste;
			int level = dvergrCompanion.Level;
			dvergrCompanion.DespawnToTotem();
			LeaderboardSync.SendTournamentJoinEscrow(slot, text, playerID, playerName, displayName, caste, seedRating2, new List<string> { item }, level, num3);
			args.Context.AddString("Sealing and registering '" + displayName + "'...");
		}

		private static void PostInviteFromConsole(Player player, WagerCurrency currency, ConsoleEventArgs args)
		{
			if (DuelInviteService.MineIn(player.GetPlayerID()) != null)
			{
				args.Context.AddString("You already have a duel invite — withdraw it first.");
			}
			else
			{
				if (!SealHovered(player, args, out var id, out var label, out var caste, out var level, out var payload))
				{
					return;
				}
				int num = Wager.DuelStake(currency);
				int clientPaidCoins = 0;
				if (currency == WagerCurrency.Coins)
				{
					if (!Wager.TryTakeCoins(player, num))
					{
						args.Context.AddString($"You need {num} Coins to stake that.");
						return;
					}
					clientPaidCoins = num;
				}
				LeaderboardSync.SendInviteAction("post", null, Wager.Key(currency), id, label, level, caste, payload, clientPaidCoins);
				args.Context.AddString("Posting a duel invite with '" + label + "'...");
			}
		}

		private static void AcceptInviteFromConsole(Player player, DuelInvite invite, ConsoleEventArgs args)
		{
			if (!SealHovered(player, args, out var id, out var label, out var caste, out var level, out var payload))
			{
				return;
			}
			WagerCurrency num = Wager.Parse(invite.currency);
			int clientPaidCoins = 0;
			if (num == WagerCurrency.Coins)
			{
				if (!Wager.TryTakeCoins(player, invite.stake))
				{
					args.Context.AddString($"You need {invite.stake} Coins to match that stake.");
					return;
				}
				clientPaidCoins = invite.stake;
			}
			LeaderboardSync.SendInviteAction("accept", invite.id, invite.currency, id, label, level, caste, payload, clientPaidCoins);
			args.Context.AddString("Accepting " + invite.hostName + "'s challenge with '" + label + "'...");
		}

		private static bool SealHovered(Player player, ConsoleEventArgs args, out string id, out string label, out int caste, out int level, out string payload)
		{
			id = null;
			label = null;
			caste = 0;
			level = 0;
			payload = null;
			GameObject hoverObject = ((Humanoid)player).GetHoverObject();
			Character val = (((Object)(object)hoverObject != (Object)null) ? hoverObject.GetComponentInParent<Character>() : null);
			DvergrCompanion dvergrCompanion = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<DvergrCompanion>() : null);
			if ((Object)(object)dvergrCompanion == (Object)null)
			{
				args.Context.AddString("Hover the companion you want to stake, then run the command.");
				return false;
			}
			if (!dvergrCompanion.IsOwner(player))
			{
				args.Context.AddString("That companion isn't yours.");
				return false;
			}
			ItemData val2 = TotemConversionService.CreateTotem(dvergrCompanion);
			if (val2 == null)
			{
				args.Context.AddString("Could not seal that companion (missing totem prefab).");
				return false;
			}
			id = dvergrCompanion.EnsureCompanionId();
			label = dvergrCompanion.DisplayName;
			caste = (int)dvergrCompanion.Caste;
			level = dvergrCompanion.Level;
			payload = TotemConversionService.SerializePayload(val2);
			dvergrCompanion.DespawnToTotem();
			return true;
		}

		private static List<DvergrCompanion> GatherFollowers(Player player, int cap)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			long playerID = player.GetPlayerID();
			List<Character> list = new List<Character>();
			Character.GetCharactersInRange(((Component)player).transform.position, 25f, list);
			List<DvergrCompanion> list2 = new List<DvergrCompanion>();
			foreach (Character item in list)
			{
				DvergrCompanion component = ((Component)item).GetComponent<DvergrCompanion>();
				if (!((Object)(object)component == (Object)null) && component.OwnerId == playerID && component.Stance == CompanionStance.Follow)
				{
					ChoreAI component2 = ((Component)item).GetComponent<ChoreAI>();
					if ((component2 == null || !component2.IsAssigned) && !component.InAnyDuelMode && !component.IsFeral)
					{
						list2.Add(component);
					}
				}
			}
			list2.Sort((DvergrCompanion a, DvergrCompanion b) => Vector3.Distance(((Component)player).transform.position, ((Component)a).transform.position).CompareTo(Vector3.Distance(((Component)player).transform.position, ((Component)b).transform.position)));
			if (list2.Count > cap)
			{
				list2 = list2.GetRange(0, cap);
			}
			return list2;
		}

		private static void PrintBracket(ConsoleEventArgs args)
		{
			List<TournamentState> list = TournamentService.All.ToList();
			if (list.Count == 0)
			{
				args.Context.AddString("No tournament is running.");
				return;
			}
			foreach (TournamentState item in list)
			{
				string text = (string.IsNullOrEmpty(item.currency) ? "free" : item.currency);
				args.Context.AddString("=== Tournament [" + text + "] (" + item.mode + ") - " + item.phase + " ===");
				if (item.entryFee > 0)
				{
					args.Context.AddString($"    entry {item.entryFee} / purse {item.prize} / opened by {item.hostName}");
				}
				if (item.phase == "registration")
				{
					args.Context.AddString(string.Format("Entrants ({0}{1}):", item.entrants.Count, (item.size > 0) ? ("/" + item.size) : ""));
					foreach (TournamentEntrant entrant in item.entrants)
					{
						args.Context.AddString($"  - {entrant.label} ({entrant.ownerName})  [{entrant.seedRating}]");
					}
					continue;
				}
				if (item.phase == "complete")
				{
					args.Context.AddString("Champion: " + item.championLabel);
					continue;
				}
				int num = 0;
				foreach (TournamentMatch match in item.matches)
				{
					if (match.round > num)
					{
						num = match.round;
					}
				}
				for (int i = 1; i <= num; i++)
				{
					args.Context.AddString($"-- Round {i} --");
					foreach (TournamentMatch match2 in item.matches)
					{
						if (match2.round == i)
						{
							string text2 = ((!string.IsNullOrEmpty(match2.winnerId)) ? ("winner: " + ((match2.winnerId == match2.aId) ? match2.aLabel : match2.bLabel)) : (match2.activated ? "fighting" : ("pending (ready " + (match2.aReady ? "Y" : "N") + "/" + (match2.bReady ? "Y" : "N") + ")")));
							string text3 = (string.IsNullOrEmpty(match2.bId) ? "(bye)" : match2.bLabel);
							args.Context.AddString("  " + match2.aLabel + " vs " + text3 + " - " + text2);
						}
					}
				}
			}
		}

		private static bool TryParseCaste(string s, out DvergrCaste caste)
		{
			switch (s.ToLowerInvariant())
			{
			case "rogue":
				caste = DvergrCaste.Rogue;
				return true;
			case "fire":
			case "firemage":
				caste = DvergrCaste.FireMage;
				return true;
			case "icemage":
			case "ice":
				caste = DvergrCaste.IceMage;
				return true;
			case "support":
			case "supportmage":
				caste = DvergrCaste.SupportMage;
				return true;
			default:
				caste = DvergrCaste.Rogue;
				return false;
			}
		}

		[CompilerGenerated]
		internal static string <Postfix>g__SlotAt|1_23(int index, ref <>c__DisplayClass1_0 P_1)
		{
			if (P_1.args.Length <= index)
			{
				return "";
			}
			return P_1.args[index].ToLowerInvariant();
		}
	}
	internal static class ChoreHint
	{
		public static string Line(Object anchorObj, string verb)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = (GameObject)(object)((anchorObj is GameObject) ? anchorObj : null);
			if ((Object)(object)val == (Object)null)
			{
				Component val2 = (Component)(object)((anchorObj is Component) ? anchorObj : null);
				if (val2 != null)
				{
					val = val2.gameObject;
				}
			}
			ChoreAI choreAI = (((Object)(object)val != (Object)null) ? ChoreAI.ClaimantOf(val) : null);
			if ((Object)(object)choreAI != (Object)null)
			{
				return "\n<color=orange>" + choreAI.WorkerName + " is already working here.</color>";
			}
			if (!DvergrCompanion.PlayerHasCompanion(Player.m_localPlayer))
			{
				return null;
			}
			return $"\n<color=yellow>[{Plugin.ChoreAssignKey.Value}] {verb}</color>";
		}

		public static string FeedLine(Character ch)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ch == (Object)null || !ch.IsTamed())
			{
				return null;
			}
			if ((Object)(object)((Component)ch).GetComponent<DvergrCompanion>() != (Object)null)
			{
				return null;
			}
			ChoreAI choreAI = ChoreAI.FeederCovering(((Component)ch).transform.position);
			if ((Object)(object)choreAI != (Object)null)
			{
				return "\n<color=orange>" + choreAI.WorkerName + " is already working here.</color>";
			}
			if (!DvergrCompanion.PlayerHasCompanion(Player.m_localPlayer))
			{
				return null;
			}
			return $"\n<color=yellow>[{Plugin.ChoreAssignKey.Value}] Set companion to feed</color>";
		}

		public static void AppendOnce(ref string result, string line)
		{
			if (!string.IsNullOrEmpty(line) && (result == null || !result.Contains(line)))
			{
				result += line;
			}
		}
	}
	[HarmonyPatch(typeof(Switch), "GetHoverText")]
	public static class SmelterSwitchChoreHintPatch
	{
		public static void Postfix(Switch __instance, ref string __result)
		{
			if ((Object)(object)__instance == (Object)null)
			{
				return;
			}
			Smelter componentInParent = ((Component)__instance).GetComponentInParent<Smelter>();
			if (!((Object)(object)componentInParent == (Object)null))
			{
				string text = ChoreHint.Line((Object)(object)((Component)componentInParent).gameObject, "Set companion to work");
				if (text != null)
				{
					__result += text;
				}
			}
		}
	}
	[HarmonyPatch(typeof(CookingStation), "GetHoverText")]
	public static class CookingChoreHintPatch
	{
		public static void Postfix(CookingStation __instance, ref string __result)
		{
			string text = ChoreHint.Line((Object)(object)__instance, "Set companion to cook");
			if (text != null)
			{
				__result += text;
			}
		}
	}
	[HarmonyPatch(typeof(Fermenter), "GetHoverText")]
	public static class FermenterChoreHintPatch
	{
		public static void Postfix(Fermenter __instance, ref string __result)
		{
			string text = ChoreHint.Line((Object)(object)__instance, "Set companion to brew");
			if (text != null)
			{
				__result += text;
			}
		}
	}
	[HarmonyPatch(typeof(Container), "GetHoverText")]
	public static class ContainerChoreHintPatch
	{
		public static void Postfix(Container __instance, ref string __result)
		{
			string text = ChoreHint.Line((Object)(object)__instance, "Set companion to haul here");
			if (text != null)
			{
				__result += text;
			}
		}
	}
	[HarmonyPatch(typeof(Tameable), "GetHoverText")]
	public static class TameableChoreHintPatch
	{
		public static void Postfix(Tameable __instance, ref string __result)
		{
			if (!((Object)(object)__instance == (Object)null))
			{
				string line = ChoreHint.FeedLine(((Component)__instance).GetComponent<Character>());
				ChoreHint.AppendOnce(ref __result, line);
			}
		}
	}
	[HarmonyPatch(typeof(Character), "GetHoverText")]
	public static class CharacterFeedChoreHintPatch
	{
		public static void Postfix(Character __instance, ref string __result)
		{
			string line = ChoreHint.FeedLine(__instance);
			ChoreHint.AppendOnce(ref __result, line);
		}
	}
	[HarmonyPatch(typeof(Pickable), "GetHoverText")]
	public static class PickableChoreHintPatch
	{
		public static void Postfix(Pickable __instance, ref string __result)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance == (Object)null)
			{
				return;
			}
			Vector3 position = ((Component)__instance).transform.position;
			Heightmap val = Heightmap.FindHeightmap(position);
			if (!((Object)(object)val == (Object)null) && val.IsCultivated(position))
			{
				string text = ChoreHint.Line((Object)(object)((Component)__instance).gameObject, "Set companion to farm here");
				if (text != null)
				{
					__result += text;
				}
			}
		}
	}
	[HarmonyPatch(typeof(ItemStand), "GetHoverText")]
	public static class ItemStandFarmHintPatch
	{
		public static void Postfix(ItemStand __instance, ref string __result)
		{
			if (!((Object)(object)__instance == (Object)null) && __instance.HaveAttachment() && !(__instance.GetAttachedItem() != "Cultivator"))
			{
				string text = ChoreHint.Line((Object)(object)((Component)__instance).gameObject, "Set companion to farm this field");
				if (text != null)
				{
					__result += text;
				}
			}
		}
	}
	[HarmonyPatch(typeof(Container), "GetHoverText")]
	public static class CompanionContainerHoverTextPatch
	{
		public static bool Prefix(Container __instance, ref string __result)
		{
			if ((Object)(object)((Component)__instance).GetComponent<DvergrCompanion>() == (Object)null)
			{
				return true;
			}
			__result = string.Empty;
			return false;
		}
	}
	[HarmonyPatch(typeof(Container), "GetHoverName")]
	public static class CompanionContainerHoverNamePatch
	{
		public static bool Prefix(Container __instance, ref string __result)
		{
			if ((Object)(object)((Component)__instance).GetComponent<DvergrCompanion>() == (Object)null)
			{
				return true;
			}
			__result = string.Empty;
			return false;
		}
	}
	[HarmonyPatch(typeof(Container), "Interact")]
	public static class CompanionContainerInteractPatch
	{
		public static bool Prefix(Container __instance, ref bool __result)
		{
			if ((Object)(object)((Component)__instance).GetComponent<DvergrCompanion>() == (Object)null)
			{
				return true;
			}
			__result = false;
			return false;
		}
	}
	[HarmonyPatch(typeof(Character), "OnDeath")]
	public static class CompanionDeathDropPatch
	{
		public static void Prefix(Character __instance)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance == (Object)null)
			{
				return;
			}
			DvergrCompanion component = ((Component)__instance).GetComponent<DvergrCompanion>();
			if ((Object)(object)component == (Object)null)
			{
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null && component.OwnerId != 0L && component.IsOwner(localPlayer))
			{
				CompanionMapPins.AddDeathMarker(component.DisplayName, ((Component)__instance).transform.position);
			}
			CompanionInventory component2 = ((Component)__instance).GetComponent<CompanionInventory>();
			Inventory val = (((Object)(object)component2 != (Object)null) ? component2.Inventory : null);
			if (val == null || val.NrOfItems() == 0)
			{
				return;
			}
			ZNetView component3 = ((Component)__instance).GetComponent<ZNetView>();
			if ((Object)(object)component3 != (Object)null && component3.IsValid() && !component3.IsOwner())
			{
				return;
			}
			Vector3 val2 = ((Component)__instance).transform.position + Vector3.up * 0.5f;
			Vector3 val3 = default(Vector3);
			foreach (ItemData item in new List<ItemData>(val.GetAllItems()))
			{
				if (item != null)
				{
					((Vector3)(ref val3))..ctor(Random.Range(-0.6f, 0.6f), 0f, Random.Range(-0.6f, 0.6f));
					ItemDrop.DropItem(item, item.m_stack, val2 + val3, Quaternion.identity);
				}
			}
			val.RemoveAll();
			Plugin.Log.LogInfo((object)"[inventory] Companion died — spilled its pack to the ground.");
		}
	}
	[HarmonyPatch(typeof(Character), "GetHoverText")]
	public static class CompanionHoverTextPatch
	{
		public static void Postfix(Character __instance, ref string __result)
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			DvergrCompanion component = ((Component)__instance).GetComponent<DvergrCompanion>();
			if ((Object)(object)component == (Object)null || !component.IsOwner(Player.m_localPlayer))
			{
				return;
			}
			string text = ((component.Stance == CompanionStance.Guard) ? "Guard" : ((component.Stance == CompanionStance.Standby) ? "Standby" : "Follow"));
			__result = __result + "\n<color=#9FD0FF>Stance: " + text + "</color>" + $"\n<color=yellow>[{Plugin.StanceCycleKey.Value}] Cycle stance</color>" + $"\n<color=yellow>[{Plugin.InventoryKey.Value}] Inventory / rename</color>";
			if (SealingRite.HasStaffEquipped(Player.m_localPlayer))
			{
				if (SealingRite.CanSeal(Player.m_localPlayer, component, out var reason))
				{
					__result += $"\n<color=#C8A2FF>Hold [Block] — Seal into a totem ({SealingRite.SealSeconds(Player.m_localPlayer):0.0}s)</color>";
				}
				else if (!string.IsNullOrEmpty(reason))
				{
					__result = __result + "\n<color=#BB8888>Cannot seal: " + reason + "</color>";
				}
			}
			ChoreAI component2 = ((Component)__instance).GetComponent<ChoreAI>();
			if (component2 != null && component2.IsAssigned)
			{
				__result += $"\n<color=yellow>[{Plugin.ChoreAssignKey.Value}] Recall from chore</color>";
			}
			if (component.DuelMode)
			{
				__result += $"\n<color=yellow>[{Plugin.DuelSelectKey.Value}] Stand down from duel</color>";
			}
			else if (component.PartyDuelMode)
			{
				__result += $"\n<color=yellow>[{Plugin.PartyDuelKey.Value}] Stand your party down</color>";
			}
			else if (component.HasPotentialDuelRivalNearby())
			{
				__result = __result + $"\n<color=yellow>[{Plugin.DuelSelectKey.Value}] Duel a rival companion nearby</color>" + $"\n<color=yellow>[{Plugin.PartyDuelKey.Value}] Party duel (gather your team)</color>";
			}
		}
	}
	[HarmonyPatch(typeof(Character), "GetHoverName")]
	public static class CompanionNameBadgePatch
	{
		public static void Postfix(Character __instance, ref string __result)
		{
			DvergrCompanion component = ((Component)__instance).GetComponent<DvergrCompanion>();
			if ((Object)(object)component == (Object)null)
			{
				return;
			}
			if (component.HasCustomName)
			{
				__result = component.DisplayName;
			}
			string ownerName = component.OwnerName;
			if (!string.IsNullOrEmpty(ownerName))
			{
				__result = __result + "  <color=#B0B0B0>(" + ownerName + ")</color>";
			}
			__result += $"  <color=#FFD24A>★{component.Level}</color>";
			if (Plugin.ShowRankOnNameTag != null && Plugin.ShowRankOnNameTag.Value)
			{
				int num = LeaderboardStore.RankOf(component.CompanionId);
				if (num > 0)
				{
					__result += $"  <color=#7FD0FF>#{num}</color>";
				}
			}
		}
	}
	[HarmonyPatch(typeof(EnemyHud), "UpdateHuds")]
	public static class CompanionHideVanillaStarsPatch
	{
		public static void Postfix(EnemyHud __instance)
		{
			if ((Object)(object)__instance == (Object)null || __instance.m_huds == null)
			{
				return;
			}
			foreach (KeyValuePair<Character, HudData> hud in __instance.m_huds)
			{
				Character key = hud.Key;
				if (!((Object)(object)key == (Object)null) && !((Object)(object)((Component)key).GetComponent<DvergrCompanion>() == (Object)null))
				{
					HudData value = hud.Value;
					if ((Object)(object)value.m_level2 != (Object)null)
					{
						((Component)value.m_level2).gameObject.SetActive(false);
					}
					if ((Object)(object)value.m_level3 != (Object)null)
					{
						((Component)value.m_level3).gameObject.SetActive(false);
					}
				}
			}
		}
	}
	[HarmonyPatch(typeof(EnemyHud), "UpdateHuds")]
	public static class CompanionStatusIconPatch
	{
		public static void Postfix(EnemyHud __instance)
		{
			if ((Object)(object)__instance == (Object)null || __instance.m_huds == null)
			{
				return;
			}
			foreach (KeyValuePair<Character, HudData> hud in __instance.m_huds)
			{
				Character key = hud.Key;
				if ((Object)(object)key == (Object)null)
				{
					continue;
				}
				DvergrCompanion component = ((Component)key).GetComponent<DvergrCompanion>();
				if ((Object)(object)component == (Object)null)
				{
					continue;
				}
				HudData value = hud.Value;
				if (value != null && !((Object)(object)value.m_gui == (Object)null))
				{
					CompanionHudStatusIcons companionHudStatusIcons = value.m_gui.GetComponent<CompanionHudStatusIcons>();
					if ((Object)(object)companionHudStatusIcons == (Object)null)
					{
						companionHudStatusIcons = value.m_gui.AddComponent<CompanionHudStatusIcons>();
					}
					companionHudStatusIcons.Refresh(component, value);
				}
			}
		}
	}
	public class CompanionHudStatusIcons : MonoBehaviour
	{
		private readonly List<Image> _pool = new List<Image>();

		private readonly List<Sprite> _sprites = new List<Sprite>();

		private static Sprite _encumberedSprite;

		private static bool _encumberedResolved;

		private const float IconSize = 22f;

		private const float Gap = 2f;

		public void Refresh(DvergrCompanion companion, HudData hud)
		{
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			Transform anchor = (((Object)(object)hud.m_name != (Object)null) ? ((TMP_Text)hud.m_name).transform : ((Component)this).transform);
			_sprites.Clear();
			if (companion.IsFed && (Object)(object)companion.FedIcon != (Object)null)
			{
				_sprites.Add(companion.FedIcon);
			}
			if (companion.IsEncumbered && (Object)(object)EncumberedSprite() != (Object)null)
			{
				_sprites.Add(EncumberedSprite());
			}
			foreach (StatusEffect item in CompanionConsumables.ActiveResistEffects(hud.m_character))
			{
				if ((Object)(object)item.m_icon != (Object)null)
				{
					_sprites.Add(item.m_icon);
				}
			}
			float num = (0f - ((float)_sprites.Count * 22f + (float)Mathf.Max(0, _sprites.Count - 1) * 2f)) * 0.5f + 11f;
			for (int i = 0; i < _sprites.Count; i++)
			{
				Image icon = GetIcon(i, anchor);
				icon.sprite = _sprites[i];
				((Graphic)icon).rectTransform.anchoredPosition = new Vector2(num + (float)i * 24f, 6f);
				((Component)icon).gameObject.SetActive(true);
			}
			for (int j = _sprites.Count; j < _pool.Count; j++)
			{
				((Component)_pool[j]).gameObject.SetActive(false);
			}
		}

		private Image GetIcon(int index, Transform anchor)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			if (index < _pool.Count)
			{
				return _pool[index];
			}
			GameObject val = new GameObject($"LS_StatusIcon{index}", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			RectTransform component = val.GetComponent<RectTransform>();
			((Transform)component).SetParent(anchor, false);
			component.anchorMin = new Vector2(0.5f, 1f);
			component.anchorMax = new Vector2(0.5f, 1f);
			component.pivot = new Vector2(0.5f, 0f);
			component.sizeDelta = new Vector2(22f, 22f);
			Image component2 = val.GetComponent<Image>();
			((Graphic)component2).raycastTarget = false;
			component2.preserveAspect = true;
			_pool.Add(component2);
			return component2;
		}

		private static Sprite EncumberedSprite()
		{
			if (_encumberedResolved)
			{
				return _encumberedSprite;
			}
			_encumberedResolved = true;
			if ((Object)(object)ObjectDB.instance != (Object)null)
			{
				StatusEffect statusEffect = ObjectDB.instance.GetStatusEffect(StringExtensionMethods.GetStableHashCode("Encumbered"));
				if ((Object)(object)statusEffect != (Object)null)
				{
					_encumberedSprite = statusEffect.m_icon;
				}
			}
			return _encumberedSprite;
		}
	}
	[HarmonyPatch(typeof(BaseAI), "IsEnemy", new Type[]
	{
		typeof(Character),
		typeof(Character)
	})]
	public static class CompanionIsEnemyPatch
	{
		public static void Postfix(Character a, Character b, ref bool __result)
		{
			if (!((Object)(object)a == (Object)null) && !((Object)(object)b == (Object)null))
			{
				DvergrCompanion component = ((Component)a).GetComponent<DvergrCompanion>();
				DvergrCompanion component2 = ((Component)b).GetComponent<DvergrCompanion>();
				if (((Object)(object)component != (Object)null && component.InAnyDuelMode) || ((Object)(object)component2 != (Object)null && component2.InAnyDuelMode))
				{
					__result = (Object)(object)component != (Object)null && (Object)(object)component2 != (Object)null && component.OwnerId != 0L && component2.OwnerId != 0L && component.OwnerId != component2.OwnerId && ((component.DuelMode && component2.DuelMode) || (component.PartyDuelMode && component2.PartyDuelMode)) && component.MatchesDuelAssignment(component2) && component2.MatchesDuelAssignment(component);
				}
				else if (!__result && (Hostile(a, b) || Hostile(b, a)))
				{
					__result = true;
				}
			}
		}

		private static bool Hostile(Character maybeCompanion, Character maybeTarget)
		{
			if ((Object)(object)maybeTarget == (Object)null)
			{
				return false;
			}
			DvergrCompanion component = ((Component)maybeCompanion).GetComponent<DvergrCompanion>();
			if ((Object)(object)component != (Object)null)
			{
				return component.IsHostileTo(maybeTarget);
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(Character), "Damage")]
	public static class CompanionDamagePatch
	{
		public static bool Prefix(Character __instance, HitData hit)
		{
			if ((Object)(object)__instance == (Object)null || hit == null)
			{
				return true;
			}
			Character attacker = hit.GetAttacker();
			Player val = (Player)(object)((attacker is Player) ? attacker : null);
			DvergrCompanion component = ((Component)__instance).GetComponent<DvergrCompanion>();
			if ((Object)(object)component != (Object)null)
			{
				if (component.InAnyDuelMode)
				{
					if ((Object)(object)val != (Object)null)
					{
						return false;
					}
					if (component.IsDuelResolved)
					{
						return false;
					}
					float num = __instance.GetMaxHealth() * 0.05f;
					if (__instance.GetHealth() - hit.GetTotalDamage() <= num)
					{
						__instance.SetHealth(num);
						if (component.PartyDuelMode)
						{
							component.ResolvePartySubdue();
						}
						else
						{
							DvergrCompanion winner = (((Object)(object)attacker != (Object)null) ? ((Component)attacker).GetComponent<DvergrCompanion>() : null);
							component.ResolveSubdue(winner);
						}
						return false;
					}
					return true;
				}
				if ((Object)(object)val != (Object)null)
				{
					if (IsButcherKnife(attacker))
					{
						component.GoFeral((Character)(object)val);
					}
					else if (!component.IsOwner(val))
					{
						component.Retaliate((Character)(object)val);
						component.MarkOwnersCompanionsHostile(val.GetPlayerID());
					}
				}
				return true;
			}
			Player val2 = (Player)(object)((__instance is Player) ? __instance : null);
			if ((Object)(object)val2 != (Object)null && (Object)(object)val != (Object)null && (Object)(object)val2 != (Object)(object)val)
			{
				long playerID = val.GetPlayerID();
				long playerID2 = val2.GetPlayerID();
				foreach (DvergrCompanion item in DvergrCompanion.All)
				{
					if (!((Object)(object)item == (Object)null))
					{
						if (item.OwnerId == playerID && item.Stance == CompanionStance.Follow)
						{
							item.MarkHostile((Character)(object)val2);
						}
						if (item.OwnerId == playerID2 && ((Character)val2).IsPVPEnabled() && ((Character)val).IsPVPEnabled())
						{
							item.MarkHostile((Character)(object)val);
							item.MarkOwnersCompanionsHostile(playerID);
						}
					}
				}
			}
			return true;
		}

		private static bool IsButcherKnife(Character attacker)
		{
			Humanoid val = (Humanoid)(object)((attacker is Humanoid) ? attacker : null);
			ItemData val2 = (((Object)(object)val != (Object)null) ? val.GetCurrentWeapon() : null);
			if (val2 == null)
			{
				return false;
			}
			string text = (((Object)(object)val2.m_dropPrefab != (Object)null) ? ((Object)val2.m_dropPrefab).name : null);
			string text2 = ((val2.m_shared != null) ? val2.m_shared.m_name : null);
			if (text == null || text.IndexOf("Butcher", StringComparison.OrdinalIgnoreCase) < 0)
			{
				if (text2 != null)
				{
					return text2.IndexOf("butcher", StringComparison.OrdinalIgnoreCase) >= 0;
				}
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(ItemData), "GetTooltip", new Type[]
	{
		typeof(ItemData),
		typeof(int),
		typeof(bool),
		typeof(float),
		typeof(int)
	})]
	public static class CompanionTotemTooltipPatch
	{
		public static void Postfix(ItemData item, ref string __result)
		{
			if (TotemConversionService.IsCompanionTotem(item))
			{
				__result += TotemConversionService.BuildTooltipBlock(item);
			}
		}
	}
	[HarmonyPatch(typeof(ItemDrop), "LoadFromZDO", new Type[]
	{
		typeof(ItemData),
		typeof(ZDO)
	})]
	public static class CompanionTotemLoadZdoPatch
	{
		public static void Postfix(ItemData itemData)
		{
			TotemConversionService.ReapplyTotemShared(itemData);
		}
	}
	[HarmonyPatch(typeof(ItemDrop), "LoadFromZDO", new Type[]
	{
		typeof(int),
		typeof(ItemData),
		typeof(ZDO)
	})]
	public static class CompanionTotemLoadIndexedPatch
	{
		public static void Postfix(ItemData itemData)
		{
			TotemConversionService.ReapplyTotemShared(itemData);
		}
	}
	[HarmonyPatch(typeof(Humanoid), "UseItem")]
	public static class CompanionTotemUsePatch
	{
		public static bool Prefix(Humanoid __instance, Inventory inventory, ItemData item)
		{
			if ((Object)(object)__instance != (Object)(object)Player.m_localPlayer)
			{
				return true;
			}
			if (!TotemConversionService.IsCompanionTotem(item))
			{
				return true;
			}
			Player val = (Player)(object)((__instance is Player) ? __instance : null);
			Inventory val2 = inventory ?? __instance.m_inventory;
			if ((Object)(object)val == (Object)null || val2 == null || !val2.ContainsItem(item))
			{
				return true;
			}
			if (TotemConversionService.TrySummon(val, item))
			{
				val2.RemoveItem(item, 1);
				((Character)val).Message((MessageType)2, "The totem cracks — your companion returns.", 0, (Sprite)null);
			}
			else
			{
				((Character)val).Message((MessageType)2, "There is no room here to summon your companion.", 0, (Sprite)null);
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(ZInput), "GetButtonDown")]
	public static class CompanionTypingButtonDownPatch
	{
		public static bool Prefix(ref bool __result)
		{
			if (!CompanionInventoryGui.IsTyping)
			{
				return true;
			}
			__result = false;
			return false;
		}
	}
	[HarmonyPatch(typeof(BaseAI), "SetAggravated")]
	public static class CorruptionAwakensPatch
	{
		private const float Cooldown = 6f;

		private const float NearRange = 40f;

		private static float _lastShown = -999f;

		private static int _nextLine;

		private static readonly string[] Lines = new string[3] { "Something old stirs in it — the corruption was never truly gone. Roused, it turns on you.", "You have woken the shadow sleeping in its blood. This is why they rage.", "The old corruption rises in it, provoked. It knows only wrath now." };

		public static void Prefix(BaseAI __instance, bool aggro)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Invalid comparison between Unknown and I4
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			if (!aggro || __instance.m_aggravated)
			{
				return;
			}
			Character component = ((Component)__instance).GetComponent<Character>();
			if (!((Object)(object)component == (Object)null) && (int)component.m_faction == 10 && !((Object)(object)((Component)component).GetComponent<DvergrCompanion>() != (Object)null) && !((Object)(object)((Component)component).GetComponent<BountyTarget>() != (Object)null))
			{
				Player localPlayer = Player.m_localPlayer;
				if (!((Object)(object)localPlayer == (Object)null) && !((Object)(object)MessageHud.instance == (Object)null) && !(Vector3.Distance(((Component)localPlayer).transform.position, ((Component)component).transform.position) > 40f) && !(Time.time - _lastShown < 6f))
				{
					_lastShown = Time.time;
					string text = Lines[_nextLine % Lines.Length];
					_nextLine++;
					MessageHud.instance.ShowMessage((MessageType)2, text, 0, (Sprite)null, false);
				}
			}
		}
	}
	[HarmonyPatch(typeof(Character), "GetHoverText")]
	public static class HoverTextPatch
	{
		public static void Postfix(Character __instance, ref string __result)
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			DvergrCompanion component = ((Component)__instance).GetComponent<DvergrCompanion>();
			if ((Object)(object)component != (Object)null)
			{
				string arg = (component.IsMaxLevel ? "max" : $"{component.XpPercentToNextLevel:F0}% to next");
				__result = __result + $"\n<color=yellow>{component.Caste.Display()}</color> · Lv {component.Level} ({arg})" + $"\n<color=yellow>[{Plugin.CommunionKey.Value}] Feed</color>";
			}
			else if (CommunionService.IsSubduedDvergr(__instance))
			{
				__result = __result + "\n<color=yellow>Hold [" + BlockKeyLabel() + "] — Communion</color>";
			}
		}

		private static string BlockKeyLabel()
		{
			try
			{
				if (ZInput.instance != null)
				{
					string text = ZInput.instance.GetBoundKeyString("Block", false);
					if (!string.IsNullOrEmpty(text) && Localization.instance != null)
					{
						text = Localization.instance.Localize(text);
					}
					if (!string.IsNullOrEmpty(text) && !text.Contains("$"))
					{
						return text;
					}
				}
			}
			catch
			{
			}
			return "Block";
		}
	}
	[HarmonyPatch(typeof(Incinerator), "OnIncinerate")]
	public static class IncineratorConversionPatch
	{
		private const float GatherRange = 15f;

		public static bool Prefix(Incinerator __instance, Humanoid user, ref bool __result)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			Player val = (Player)(object)((user is Player) ? user : null);
			if ((Object)(object)val == (Object)null || (Object)(object)val != (Object)(object)Player.m_localPlayer)
			{
				return true;
			}
			if ((Object)(object)__instance == (Object)null || (Object)(object)__instance.m_nview == (Object)null || !__instance.m_nview.IsValid())
			{
				return true;
			}
			if (!PrivateArea.CheckAccess(((Component)__instance).transform.position, 0f, true, false))
			{
				return true;
			}
			if ((Object)(object)__instance.m_container == (Object)null)
			{
				return true;
			}
			Inventory inventory = __instance.m_container.GetInventory();
			if (inventory == null)
			{
				return true;
			}
			string text = TotemConversionService.WispSharedName();
			if (((!string.IsNullOrEmpty(text) && inventory.CountItems(text, -1, true) != 0) ? 1 : 0) <= (false ? 1 : 0))
			{
				return true;
			}
			if (GatherFollowers(val, ((Component)__instance).transform.position).Count == 0)
			{
				return true;
			}
			__result = true;
			if ((Object)(object)Plugin.Instance != (Object)null)
			{
				((MonoBehaviour)Plugin.Instance).StartCoroutine(SealRitual(__instance, val, text));
			}
			return false;
		}

		private static List<DvergrCompanion> GatherFollowers(Player player, Vector3 origin)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			List<DvergrCompanion> list = new List<DvergrCompanion>();
			foreach (DvergrCompanion item in DvergrCompanion.All)
			{
				if (!((Object)(object)item == (Object)null) && item.IsOwner(player) && item.Stance == CompanionStance.Follow && !item.ChoreActive && !item.DuelMode)
				{
					Character component = ((Component)item).GetComponent<Character>();
					if (!((Object)(object)component == (Object)null) && !component.IsDead() && !(Vector3.Distance(origin, ((Component)item).transform.position) > 15f))
					{
						list.Add(item);
					}
				}
			}
			list.Sort((DvergrCompanion a, DvergrCompanion b) => Vector3.Distance(origin, ((Component)a).transform.position).CompareTo(Vector3.Distance(origin, ((Component)b).transform.position)));
			return list;
		}

		private static IEnumerator SealRitual(Incinerator inc, Player player, string wispName)
		{
			ZNetView nview = inc.m_nview;
			nview.ClaimOwnership();
			ZNetView component = ((Component)inc.m_container).GetComponent<ZNetView>();
			if ((Object)(object)component != (Object)null && component.IsValid())
			{
				component.ClaimOwnership();
			}
			nview.InvokeRPC(ZNetView.Everybody, "RPC_AnimateLever", Array.Empty<object>());
			inc.m_leverEffects.Create(((Component)inc).transform.position, ((Component)inc).transform.rotation, (Transform)null, 1f, -1);
			yield return (object)new WaitForSeconds(Random.Range(inc.m_effectDelayMin, inc.m_effectDelayMax));
			nview.InvokeRPC(ZNetView.Everybody, "RPC_AnimateLeverReturn", Array.Empty<object>());
			if ((Object)(object)inc.m_lightingAOEs != (Object)null)
			{
				Object.Instantiate<GameObject>(inc.m_lightingAOEs, ((Component)inc).transform.position, ((Component)inc).transform.rotation);
			}
			Inventory inventory = inc.m_container.GetInventory();
			if (inventory == null)
			{
				yield break;
			}
			int num = ((!string.IsNullOrEmpty(wispName)) ? inventory.CountItems(wispName, -1, true) : 0);
			List<DvergrCompanion> list = GatherFollowers(player, ((Component)inc).transform.position);
			int num2 = Mathf.Min(num, list.Count);
			int num3 = 0;
			for (int i = 0; i < num2; i++)
			{
				DvergrCompanion dvergrCompanion = list[i];
				if (!((Object)(object)dvergrCompanion == (Object)null))
				{
					ItemData val = TotemConversionService.CreateTotem(dvergrCompanion);
					if (val == null)
					{
						break;
					}
					if (!inventory.AddItem(val))
					{
						((Character)player).Message((MessageType)2, "The incinerator has no room for more totems.", 0, (Sprite)null);
						break;
					}
					inventory.RemoveItem(wispName, 1, -1, true);
					TotemConversionService.PlaySealVfx(((Component)dvergrCompanion).transform.position + Vector3.up);
					DissolveCompanion(dvergrCompanion);
					num3++;
				}
			}
			if (num3 > 0)
			{
				((Character)player).Message((MessageType)2, (num3 == 1) ? "A companion is sealed within a totem." : $"{num3} companions are sealed within totems.", 0, (Sprite)null);
			}
		}

		private static void DissolveCompanion(DvergrCompanion companion)
		{
			GameObject gameObject = ((Component)companion).gameObject;
			ZNetView component = gameObject.GetComponent<ZNetView>();
			if ((Object)(object)component != (Object)null && component.IsValid())
			{
				component.ClaimOwnership();
				ZNetScene.instance.Destroy(gameObject);
			}
			else
			{
				Object.Destroy((Object)(object)gameObject);
			}
		}
	}
	[HarmonyPatch(typeof(Character), "OnDeath")]
	public static class KillXpPatch
	{
		private const float XpShareRadius = 20f;

		private const float PlayerKillXp = 50f;

		private const float MinXpFraction = 0.25f;

		public static void Postfix(Character __instance)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance == (Object)null || (Object)(object)((Component)__instance).GetComponent<DvergrCompanion>() != (Object)null)
			{
				return;
			}
			float num;
			if (__instance.IsPlayer())
			{
				num = 50f;
			}
			else
			{
				if ((int)__instance.m_faction == 0)
				{
					return;
				}
				num = BiomeScaledXp(__instance);
			}
			if (num <= 0f)
			{
				return;
			}
			List<Character> list = new List<Character>();
			Character.GetCharactersInRange(((Component)__instance).transform.position, 20f, list);
			foreach (Character item in list)
			{
				DvergrCompanion component = ((Component)item).GetComponent<DvergrCompanion>();
				if ((Object)(object)component != (Object)null)
				{
					component.AddXp(num);
				}
			}
		}

		private static float BiomeScaledXp(Character dead)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			GetBiomeTier(Heightmap.FindBiome(((Component)dead).transform.position), out var cap, out var referenceHp);
			float num = ((referenceHp > 0f) ? (dead.GetMaxHealth() / referenceHp) : 1f);
			num = Mathf.Clamp(num, 0.25f, 1f);
			float num2 = Mathf.Round(cap * num);
			Plugin.Log.LogInfo((object)($"[xp] Kill in {Heightmap.FindBiome(((Component)dead).transform.position)}: " + $"'{((Object)dead).name}' maxHP={dead.GetMaxHealth():F0} / ref {referenceHp:F0} " + $"-> {num2} XP (cap {cap:F0})."));
			return num2;
		}

		private static void GetBiomeTier(Biome biome, out float cap, out float referenceHp)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Invalid comparison between Unknown and I4
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected I4, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Invalid comparison between Unknown and I4
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Invalid comparison between Unknown and I4
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Invalid comparison between Unknown and I4
			if ((int)biome <= 8)
			{
				switch (biome - 1)
				{
				default:
					if ((int)biome != 8)
					{
						break;
					}
					cap = 12f;
					referenceHp = 150f;
					return;
				case 0:
					cap = 5f;
					referenceHp = 25f;
					return;
				case 1:
					cap = 22f;
					referenceHp = 150f;
					return;
				case 3:
					cap = 35f;
					referenceHp = 100f;
					return;
				case 2:
					break;
				}
			}
			else
			{
				if ((int)biome == 16)
				{
					cap = 50f;
					referenceHp = 80f;
					return;
				}
				if ((int)biome == 32)
				{
					cap = 100f;
					referenceHp = 200f;
					return;
				}
				if ((int)biome == 512)
				{
					cap = 75f;
					referenceHp = 200f;
					return;
				}
			}
			cap = 35f;
			referenceHp = 100f;
		}
	}
	[HarmonyPatch(typeof(Player), "TakeInput")]
	public static class TournamentPanelBlocksInputPatch
	{
		public static void Postfix(ref bool __result)
		{
			if (ModalPanels.AnyOpen)
			{
				__result = false;
			}
		}
	}
	[HarmonyPatch(typeof(PlayerController), "TakeInput", new Type[] { typeof(bool) })]
	public static class TournamentPanelBlocksControllerInputPatch
	{
		public static void Postfix(ref bool __result)
		{
			if (ModalPanels.AnyOpen)
			{
				__result = false;
			}
		}
	}
	[HarmonyPatch(typeof(GameCamera), "UpdateMouseCapture")]
	public static class TournamentPanelFreesCursorPatch
	{
		public static bool Prefix()
		{
			if (!ModalPanels.AnyOpen)
			{
				return true;
			}
			Cursor.lockState = (CursorLockMode)0;
			Cursor.visible = true;
			return false;
		}
	}
	[HarmonyPatch(typeof(Player), "SetMouseLook")]
	public static class TournamentPanelBlocksLookPatch
	{
		public static bool Prefix()
		{
			return !ModalPanels.AnyOpen;
		}
	}
	[HarmonyPatch(typeof(ZInput), "GetButton", new Type[] { typeof(string) })]
	public static class TournamentPanelBlocksButtonPatch
	{
		public static bool Prefix(ref bool __result)
		{
			if (!ModalPanels.AnyOpen)
			{
				return true;
			}
			__result = false;
			return false;
		}
	}
	[HarmonyPatch(typeof(ZInput), "GetButtonDown", new Type[] { typeof(string) })]
	public static class TournamentPanelBlocksButtonDownPatch
	{
		public static bool Prefix(ref bool __result)
		{
			if (!ModalPanels.AnyOpen)
			{
				return true;
			}
			__result = false;
			return false;
		}
	}
	[HarmonyPatch(typeof(ZInput), "GetButtonUp", new Type[] { typeof(string) })]
	public static class TournamentPanelBlocksButtonUpPatch
	{
		public static bool Prefix(ref bool __result)
		{
			if (!ModalPanels.AnyOpen)
			{
				return true;
			}
			__result = false;
			return false;
		}
	}
}
namespace LostScrollsII.Bounty
{
	public class BountyBoardPanel : MonoBehaviour
	{
		private static BountyBoardPanel _instance;

		private GameObject _root;

		private TMP_Text _status;

		private readonly List<GameObject> _buttons = new List<GameObject>();

		private TMP_Text _textSource;

		private Button _buttonSource;

		private string _lastSig;

		public static bool IsOpen { get; private set; }

		private void Awake()
		{
			_instance = this;
		}

		public static void Toggle(Player player)
		{
			if (!((Object)(object)_instance == (Object)null))
			{
				if (IsOpen)
				{
					_instance.Close();
				}
				else
				{
					_instance.Open(player);
				}
			}
		}

		private void Open(Player player)
		{
			if ((Object)(object)InventoryGui.instance == (Object)null)
			{
				Msg("The bounty board isn't ready yet.");
			}
			else if (EnsureBuilt())
			{
				_root.SetActive(true);
				IsOpen = true;
				Cursor.lockState = (CursorLockMode)0;
				Cursor.visible = true;
				BountySync.RequestBoard();
				_lastSig = null;
				Rebuild(player);
			}
		}

		private void Close()
		{
			IsOpen = false;
			if ((Object)(object)_root != (Object)null)
			{
				_root.SetActive(false);
			}
		}

		private void Update()
		{
			if (!IsOpen)
			{
				return;
			}
			if (Input.GetKeyDown((KeyCode)27))
			{
				Close();
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null) && StateSignature(localPlayer) != _lastSig)
			{
				Rebuild(localPlayer);
			}
		}

		private bool EnsureBuilt()
		{
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Expected O, but got Unknown
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_root != (Object)null && ((Object)(object)_textSource == (Object)null || (Object)(object)_buttonSource == (Object)null))
			{
				Object.Destroy((Object)(object)_root);
				_root = null;
				_buttons.Clear();
				_status = null;
				_lastSig = null;
			}
			if ((Object)(object)_root != (Object)null)
			{
				return true;
			}
			try
			{
				if ((Object)(object)InventoryGui.instance == (Object)null)
				{
					return false;
				}
				_textSource = InventoryGui.instance.m_containerWeight;
				_buttonSource = InventoryGui.instance.m_takeAllButton;
				if ((Object)(object)_textSource == (Object)null || (Object)(object)_buttonSource == (Object)null)
				{
					return false;
				}
				_root = new GameObject("LSII_BountyPanel");
				Canvas obj = _root.AddComponent<Canvas>();
				obj.renderMode = (RenderMode)0;
				obj.sortingOrder = 5000;
				CanvasScaler obj2 = _root.AddComponent<CanvasScaler>();
				obj2.uiScaleMode = (ScaleMode)1;
				obj2.referenceResolution = new Vector2(1920f, 1080f);
				_root.AddComponent<GraphicRaycaster>();
				Object.DontDestroyOnLoad((Object)(object)_root);
				GameObject val = NewImage(_root.transform, new Color(0.05f, 0.05f, 0.06f, 0.92f));
				RectTransform component = val.GetComponent<RectTransform>();
				Vector2 anchorMin = (component.anchorMax = new Vector2(0.5f, 0.5f));
				component.anchorMin = anchorMin;
				component.pivot = new Vector2(0.5f, 0.5f);
				component.sizeDelta = new Vector2(700f, 760f);
				_status = CloneText(val.transform, new Vector2(0f, 200f), new Vector2(660f, 330f));
				_status.alignment = (TextAlignmentOptions)257;
				_status.fontSize = 19f;
				_status.richText = true;
				return true;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[bounty-ui] Could not build the bounty panel: " + ex.Message));
				if ((Object)(object)_root != (Object)null)
				{
					Object.Destroy((Object)(object)_root);
				}
				_root = null;
				_status = null;
				_buttons.Clear();
				return false;
			}
		}

		private static GameObject NewImage(Transform parent, Color color)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			GameObject val = new GameObject("Panel", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			((Graphic)val.AddComponent<Image>()).color = color;
			return val;
		}

		private TMP_Text CloneText(Transform parent, Vector2 anchoredPos, Vector2 size)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = Object.Instantiate<GameObject>(((Component)_textSource).gameObject, parent);
			((Object)obj).name = "Text";
			RectTransform component = obj.GetComponent<RectTransform>();
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(0.5f, 0.5f);
			component.anchorMax = val;
			component.anchorMin = val;
			component.pivot = new Vector2(0.5f, 0.5f);
			component.anchoredPosition = anchoredPos;
			component.sizeDelta = size;
			TMP_Text component2 = obj.GetComponent<TMP_Text>();
			component2.enableAutoSizing = false;
			obj.SetActive(true);
			return component2;
		}

		private GameObject AddButton(string label, Vector2 anchoredPos, Action onClick, Vector2? size = null)
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Expected O, but got Unknown
			if ((Object)(object)_buttonSource == (Object)null || (Object)(object)_root == (Object)null)
			{
				return null;
			}
			GameObject val = Object.Instantiate<GameObject>(((Component)_buttonSource).gameObject, _root.transform.GetChild(0));
			((Object)val).name = "Btn_" + label;
			RectTransform component = val.GetComponent<RectTransform>();
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(0.5f, 0.5f);
			component.anchorMax = val2;
			component.anchorMin = val2;
			component.pivot = new Vector2(0.5f, 0.5f);
			component.anchoredPosition = anchoredPos;
			component.sizeDelta = (Vector2)(((??)size) ?? new Vector2(300f, 40f));
			TMP_Text componentInChildren = val.GetComponentInChildren<TMP_Text>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				componentInChildren.text = label;
				componentInChildren.enableAutoSizing = false;
				componentInChildren.fontSize = 15f;
			}
			Button component2 = val.GetComponent<Button>();
			if ((Object)(object)component2 != (Object)null)
			{
				((UnityEventBase)component2.onClick).RemoveAllListeners();
				((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
				{
					onClick();
				});
				((Selectable)component2).interactable = true;
			}
			val.SetActive(true);
			_buttons.Add(val);
			return val;
		}

		private static string StateSignature(Player player)
		{
			if (!BountyFeatureGate.AvailableToLocalPlayer)
			{
				return "off";
			}
			StringBuilder stringBuilder = new StringBuilder("on");
			stringBuilder.Append(BountyQuestGate.IsUnlocked(player) ? "|open" : "|locked");
			BountyPosting bountyPosting = BountyBoardStore.AcceptedBy(player.GetPlayerID());
			stringBuilder.Append('|').Append((bountyPosting != null) ? (bountyPosting.id + (bountyPosting.spawned ? "+s" : "")) : "none");
			foreach (BountyPosting item in BountyBoardStore.OpenPostings())
			{
				stringBuilder.Append('|').Append(item.id);
			}
			return stringBuilder.ToString();
		}

		private void Rebuild(Player player)
		{
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0266: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			_lastSig = StateSignature(player);
			foreach (GameObject button in _buttons)
			{
				if ((Object)(object)button != (Object)null)
				{
					Object.Destroy((Object)(object)button);
				}
			}
			_buttons.Clear();
			if ((Object)(object)_status == (Object)null)
			{
				return;
			}
			if (!BountyFeatureGate.AvailableToLocalPlayer)
			{
				_status.text = TeaserText();
				AddButton("Close", new Vector2(0f, -300f), (Action)Close, (Vector2?)new Vector2(300f, 44f));
				return;
			}
			_status.text = BoardText(player);
			float num = -30f;
			BountyPosting bountyPosting = BountyBoardStore.AcceptedBy(player.GetPlayerID());
			if (bountyPosting != null)
			{
				if (!bountyPosting.tutorial)
				{
					AddButton("Abandon Bounty", new Vector2(0f, num), (Action)delegate
					{
						BountySync.SendAbandon();
					}, (Vector2?)new Vector2(320f, 42f));
					num -= 48f;
				}
			}
			else if (BountyQuestGate.IsUnlocked(player))
			{
				bool flag = BountyService.IsEliteEligible(player.GetPlayerID());
				foreach (BountyPosting item in BountyBoardStore.OpenPostings())
				{
					string id = item.id;
					float num2 = Distance(player, item);
					if (BountyBoardStore.IsElite(item) && !flag)
					{
						GameObject val = AddButton($"Locked: {item.Label} — {num2:F0}m", new Vector2(0f, num), (Action)delegate
						{
						}, (Vector2?)new Vector2(560f, 40f));
						Button val2 = (((Object)(object)val != (Object)null) ? val.GetComponent<Button>() : null);
						if ((Object)(object)val2 != (Object)null)
						{
							((Selectable)val2).interactable = false;
						}
					}
					else
					{
						AddButton($"Accept: {item.Label} — {num2:F0}m", new Vector2(0f, num), (Action)delegate
						{
							BountySync.SendAccept(id);
						}, (Vector2?)new Vector2(560f, 40f));
					}
					num -= 46f;
					if (num < -250f)
					{
						break;
					}
				}
			}
			AddButton("Close", new Vector2(0f, -320f), (Action)Close, (Vector2?)new Vector2(300f, 44f));
		}

		private static float Distance(Player player, BountyPosting p)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			return Vector3.Distance(new Vector3(((Component)player).transform.position.x, 0f, ((Component)player).transform.position.z), new Vector3(p.x, 0f, p.z));
		}

		private static string BoardText(Player player)
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("<size=150%><color=#FF6B4A>The Wanted Board</color></size>\n\n");
			BountyPosting bountyPosting = BountyBoardStore.AcceptedBy(player.GetPlayerID());
			if (bountyPosting != null)
			{
				float num = Distance(player, bountyPosting);
				stringBuilder.Append(bountyPosting.tutorial ? "<color=#FFD24A>The warden's commission:</color> " : "<color=#FFD24A>Your posting:</color> ");
				stringBuilder.Append(bountyPosting.Label + "\n");
				stringBuilder.Append($"  <color=#AAAAAA>{num:F0}m away — marked on your map.</color>\n");
				stringBuilder.Append(bountyPosting.spawned ? "  <color=#FF6B4A>It knows you are coming.</color>\n\n" : "  <color=#AAAAAA>Travel there to find it.</color>\n\n");
			}
			else if (!BountyQuestGate.IsUnlocked(player))
			{
				stringBuilder.Append("<color=#AAAAAA>The board is not yours to read yet.</color>\n\n");
				stringBuilder.Append("Seek out <color=#FFD24A>Haldor</color>, the trader in the black woods, and press <color=#FFD24A>Shift + E</color> to speak with him rather than open his store. He keeps the postings, and he will not hand them to a stranger who has never answered one.\n\n");
			}
			else
			{
				List<BountyPosting> list = BountyBoardStore.OpenPostings();
				stringBuilder.Append((list.Count > 0) ? "<color=#AAAAAA>Take a posting below. It will be marked on your map.</color>\n" : "<color=#AAAAAA>No postings right now. Check back shortly.</color>\n");
				BountyPosting bountyPosting2 = list.FirstOrDefault(BountyBoardStore.IsElite);
				if (bountyPosting2 != null && !BountyService.IsEliteEligible(player.GetPlayerID()))
				{
					int num2 = Plugin.BountyEliteRankTopN?.Value ?? 10;
					stringBuilder.Append("<color=#FF6B4A>An " + BountyTiers.TierName(bountyPosting2.tier) + " posting hangs on the board.</color> " + $"<color=#AAAAAA>Only hunters in the top {num2} of the duel or party ladder may answer it.</color>\n");
				}
				stringBuilder.Append('\n');
			}
			long playerID = player.GetPlayerID();
			int num3 = BountyLeaderboardStore.RankOf(playerID);
			BountyHunterRecord bountyHunterRecord = BountyLeaderboardStore.Find(playerID);
			stringBuilder.Append("<size=120%><color=#FFD24A>Your standing</color></size>\n");
			if (bountyHunterRecord == null || num3 == 0)
			{
				stringBuilder.Append("<color=#AAAAAA>No bounties answered yet.</color>\n");
			}
			else
			{
				int num4 = Plugin.BountyLeaderboardBonusRank?.Value ?? 3;
				stringBuilder.Append($"  #{num3} · {bountyHunterRecord.points} points · {bountyHunterRecord.kills} felled / {bountyHunterRecord.communes} freed\n");
				if (num4 > 0)
				{
					stringBuilder.Append((num3 <= num4) ? "  <color=#B8F5B0>Your standing earns better rewards.</color>\n" : $"  <color=#AAAAAA>Reach #{num4} for better rewards.</color>\n");
				}
			}
			List<BountyHunterRecord> list2 = BountyLeaderboardStore.Ranked();
			if (list2.Count > 0)
			{
				stringBuilder.Append("\n<size=120%><color=#FFD24A>Best hunters</color></size>\n");
				for (int i = 0; i < list2.Count && i < 3; i++)
				{
					stringBuilder.Append($"  #{i + 1} {list2[i].ownerName} — {list2[i].points}\n");
				}
			}
			return stringBuilder.ToString();
		}

		private static string TeaserText()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("<size=150%><color=#FF6B4A>The Wanted Board</color></size>\n\n");
			stringBuilder.Append("<color=#AAAAAA>There is no board here.</color>\n\n");
			stringBuilder.Append("Some Dvergr hardened past the point where the corruption merely held them — they turned it into a weapon, and they hunt the roads still. Where someone keeps a Wanted Board, those Dvergr can be hunted for pay: goods that take a forge or a cooking fire to make, and a name among the hunters who answer the hardest postings.\n\n");
			stringBuilder.Append("<color=#FFD24A>Bounty hunting runs on servers</color> with the Lost Scrolls II Quest pack alongside <color=#FFD24A>BiomeLords</color>, <color=#FFD24A>ValheimServerGuide</color> and <color=#FFD24A>Valheim Donations</color>.\n\n");
			stringBuilder.Append("<color=#AAAAAA>Everything else in Lost Scrolls II — companions, chores, duels, tournaments — works here as normal.</color>");
			return stringBuilder.ToString();
		}

		private static void Msg(string m)
		{
			if ((Object)(object)MessageHud.instance != (Object)null)
			{
				MessageHud.instance.ShowMessage((MessageType)1, m, 0, (Sprite)null, false);
			}
		}
	}
	public class BountyBoardRunner : MonoBehaviour
	{
		private const float TickInterval = 2f;

		private float _timer;

		private string _pinnedPostingId;

		private void Update()
		{
			_timer += Time.deltaTime;
			if (!(_timer < 2f))
			{
				_timer = 0f;
				if (BountyFeatureGate.IsServerAuthority && BountyFeatureGate.IsEnabled && BountyBoardStore.EnsurePostings())
				{
					BountySync.BroadcastBoard();
				}
				UpdateLocalHunter();
			}
		}

		private void UpdateLocalHunter()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || !BountyFeatureGate.AvailableToLocalPlayer)
			{
				ClearPin();
				return;
			}
			if (BountyQuestGate.HasPendingStart(localPlayer) && BountyQuestGate.ConsumeStartRequest(localPlayer))
			{
				BountySync.SendCommissionRequest(((Component)localPlayer).transform.position);
			}
			BountyPosting bountyPosting = BountyBoardStore.AcceptedBy(localPlayer.GetPlayerID());
			if (bountyPosting == null)
			{
				ClearPin();
				return;
			}
			if (_pinnedPostingId != bountyPosting.id)
			{
				ClearPin();
				_pinnedPostingId = bountyPosting.id;
			}
			BountyMapPin.Show(bountyPosting.id, bountyPosting.Label, bountyPosting.Position);
			if (bountyPosting.spawned)
			{
				return;
			}
			float num = Mathf.Max(16f, Plugin.BountyArrivalRadius?.Value ?? 80f);
			Vector3 val = new Vector3(((Component)localPlayer).transform.position.x, 0f, ((Component)localPlayer).transform.position.z);
			Vector3 val2 = default(Vector3);
			((Vector3)(ref val2))..ctor(bountyPosting.x, 0f, bountyPosting.z);
			if (Vector3.Distance(val, val2) > num)
			{
				return;
			}
			Vector3 position = bountyPosting.Position;
			float y = default(float);
			if ((Object)(object)ZoneSystem.instance != (Object)null && ZoneSystem.instance.GetSolidHeight(position, ref y, 1000))
			{
				position.y = y;
			}
			if (BountySpawner.Spawn(bountyPosting.id, bountyPosting.tier, position, bountyPosting.Biome) != null)
			{
				BountySync.SendSpawned(bountyPosting.id);
				if ((Object)(object)MessageHud.instance != (Object)null)
				{
					MessageHud.instance.ShowMessage((MessageType)2, "You have found the " + BountyTiers.TierName(bountyPosting.tier) + " one. It knows you are here.", 0, (Sprite)null, false);
				}
			}
		}

		private void ClearPin()
		{
			if (!string.IsNullOrEmpty(_pinnedPostingId))
			{
				BountyMapPin.Remove(_pinnedPostingId);
				_pinnedPostingId = null;
			}
		}
	}
	public static class BountyBoardStore
	{
		private static BountyBoardData _data;

		private static BountyBoardData _snapshot = new BountyBoardData();

		private static string _loadedWorld;

		private const float TutorialMinRadius = 150f;

		private const float TutorialMaxRadius = 1200f;

		public static BountyBoardData Snapshot => _snapshot;

		private static string StorePath(string world)
		{
			return Path.Combine(LeaderboardStore.DataDir(), "board." + Sanitize(world) + ".json");
		}

		private static string Sanitize(string s)
		{
			if (string.IsNullOrEmpty(s))
			{
				return "world";
			}
			char[] invalidFileNameChars = Path.GetInvalidFileNameChars();
			foreach (char oldChar in invalidFileNameChars)
			{
				s = s.Replace(oldChar, '_');
			}
			return s;
		}

		private static string CurrentWorldName()
		{
			try
			{
				if ((Object)(object)ZNet.instance != (Object)null)
				{
					return ZNet.instance.GetWorldName();
				}
			}
			catch
			{
			}
			return "world";
		}

		public static void LoadForCurrentWorld()
		{
			string text = (_loadedWorld = CurrentWorldName());
			string text2 = StorePath(text);
			try
			{
				if (File.Exists(text2))
				{
					_data = CompetitiveJson.ReadBountyBoard(File.ReadAllText(text2)) ?? new BountyBoardData();
					if (_data.postings == null)
					{
						_data.postings = new List<BountyPosting>();
					}
					Plugin.Log.LogInfo((object)$"[bounty] loaded {_data.postings.Count} posting(s) for world '{text}'.");
				}
				else
				{
					_data = new BountyBoardData();
					Plugin.Log.LogInfo((object)("[bounty] no board file for world '" + text + "' — starting fresh."));
				}
			}
			catch (Exception ex)
			{
				_data = new BountyBoardData();
				Plugin.Log.LogWarning((object)("[bounty] failed to load '" + text2 + "': " + ex.Message + ". Starting fresh."));
			}
			_snapshot = _data;
		}

		public static void Save()
		{
			if (_data == null)
			{
				return;
			}
			try
			{
				File.WriteAllText(StorePath(_loadedWorld ?? CurrentWorldName()), CompetitiveJson.Write(_data, pretty: true));
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[bounty] board save failed: " + ex.Message));
			}
		}

		public static string SerializeSnapshot()
		{
			return CompetitiveJson.Write(_data ?? new BountyBoardData());
		}

		public static void ApplySnapshot(string json)
		{
			try
			{
				BountyBoardData bountyBoardData = CompetitiveJson.ReadBountyBoard(json) ?? new BountyBoardData();
				if (bountyBoardData.postings == null)
				{
					bountyBoardData.postings = new List<BountyPosting>();
				}
				_snapshot = bountyBoardData;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[bounty] failed to apply board snapshot: " + ex.Message));
			}
		}

		public static bool EnsurePostings()
		{
			if (_data == null)
			{
				_data = new BountyBoardData();
			}
			int num = PruneExpired();
			int num2 = Mathf.Max(0, Plugin.BountyMaxBoardEntries?.Value ?? 3);
			int num3 = _data.postings.Count((BountyPosting p) => p?.IsOpen ?? false);
			int num4 = 0;
			for (int num5 = num3; num5 < num2; num5++)
			{
				if (!TryCreatePosting(out var posting))
				{
					break;
				}
				_data.postings.Add(posting);
				num4++;
			}
			if (num4 > 0 || num > 0)
			{
				Save();
				Plugin.Log.LogInfo((object)($"[bounty] board rotated: retired {num}, posted {num4} " + $"({_data.postings.Count} on the board)."));
			}
			if (num4 <= 0)
			{
				return num > 0;
			}
			return true;
		}

		private static int PruneExpired()
		{
			float num = Plugin.BountyRefreshHours?.Value ?? 24f;
			if (num <= 0f)
			{
				return 0;
			}
			long cutoff = DateTime.UtcNow.AddHours(0f - num).Ticks;
			return _data.postings.RemoveAll((BountyPosting p) => p != null && p.IsOpen && !p.tutorial && p.postedTicks > 0 && p.postedTicks < cutoff);
		}

		private static bool TryCreatePosting(out BountyPosting posting)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Expected I4, but got Unknown
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			posting = null;
			if (!BountyLocationSampler.TrySample(Vector3.zero, Plugin.BountySearchMinRadius?.Value ?? 500f, Plugin.BountySearchMaxRadius?.Value ?? 6000f, out var pos, out var biome, out var stats))
			{
				Plugin.Log.LogWarning((object)("[bounty] could not place a posting: " + stats));
				return false;
			}
			int tier = BountyTiers.Clamp(BountyTiers.BaseTierFor(biome));
			float num = Mathf.Clamp01(Plugin.BountyEliteChance?.Value ?? 0.25f);
			if (!_data.postings.Any((BountyPosting p) => p != null && p.IsOpen && p.tier >= 5) && num > 0f && Random.value < num)
			{
				tier = 5;
			}
			posting = new BountyPosting
			{
				id = Guid.NewGuid().ToString("N"),
				tier = tier,
				biome = (int)biome,
				x = pos.x,
				y = pos.y,
				z = pos.z,
				postedTicks = DateTime.UtcNow.Ticks
			};
			return true;
		}

		public static bool IsElite(BountyPosting p)
		{
			if (p != null)
			{
				return p.tier >= 5;
			}
			return false;
		}

		public static string CreateTutorial(long ownerId, string ownerName, Vector3 near, out BountyPosting created)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Expected I4, but got Unknown
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			created = null;
			if (_data == null)
			{
				_data = new BountyBoardData();
			}
			if (ownerId == 0L)
			{
				return "Unknown player.";
			}
			BountyPosting bountyPosting = _data.postings.FirstOrDefault((BountyPosting p) => p != null && p.acceptedBy == ownerId);
			if (bountyPosting != null)
			{
				created = bountyPosting;
				return "You already have a bounty to answer.";
			}
			if (!TrySampleNear(near, 150f, 1200f, out var pos, out var biome) && !TrySampleNear(near, 150f, 3600f, out pos, out biome))
			{
				return "The warden has no posting close enough to point you at right now.";
			}
			BountyPosting bountyPosting2 = new BountyPosting
			{
				id = Guid.NewGuid().ToString("N"),
				tier = 1,
				biome = (int)biome,
				x = pos.x,
				y = pos.y,
				z = pos.z,
				postedTicks = DateTime.UtcNow.Ticks,
				acceptedBy = ownerId,
				acceptedByName = ownerName,
				tutorial = true
			};
			_data.postings.Add(bountyPosting2);
			Save();
			created = bountyPosting2;
			Plugin.Log.LogInfo((object)("[bounty] warden's commission posted for '" + ownerName + "' — " + bountyPosting2.Label + " " + $"at ({pos.x:F0}, {pos.z:F0})."));
			return "The warden marks your map: " + bountyPosting2.Label + ".";
		}

		private static bool TrySampleNear(Vector3 near, float min, float max, out Vector3 pos, out Biome biome)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			string stats;
			return BountyLocationSampler.TrySample(near, min, max, out pos, out biome, out stats);
		}

		public static bool IsTutorial(string postingId)
		{
			return Find(postingId)?.tutorial ?? false;
		}

		public static string Accept(long ownerId, string ownerName, string postingId)
		{
			if (_data == null)
			{
				return "The board isn't ready.";
			}
			if (ownerId == 0L)
			{
				return "Unknown player.";
			}
			BountyPosting bountyPosting = Find(postingId);
			if (bountyPosting == null)
			{
				return "That posting is no longer on the board.";
			}
			if (!bountyPosting.IsOpen)
			{
				if (bountyPosting.acceptedBy != ownerId)
				{
					return bountyPosting.acceptedByName + " has already taken that posting.";
				}
				return "You have already taken that posting.";
			}
			int num = Mathf.Max(1, Plugin.BountyMaxActivePerPlayer?.Value ?? 1);
			int num2 = _data.postings.Count((BountyPosting p) => p != null && p.acceptedBy == ownerId);
			if (num2 >= num)
			{
				if (num != 1)
				{
					return $"You already hold {num2} bounties (limit {num}).";
				}
				return "You already have an active bounty. Finish or abandon it first.";
			}
			if (IsElite(bountyPosting) && !BountyService.IsEliteEligible(ownerId))
			{
				int num3 = Plugin.BountyEliteRankTopN?.Value ?? 10;
				return "Only the realm's finest may answer an " + BountyTiers.TierName(bountyPosting.tier) + " posting " + $"— reach the top {num3} on the duel or party ladder first.";
			}
			bountyPosting.acceptedBy = ownerId;
			bountyPosting.acceptedByName = ownerName;
			Save();
			return "Accepted: " + bountyPosting.Label + ".";
		}

		public static string Abandon(long ownerId)
		{
			if (_data == null)
			{
				return "The board isn't ready.";
			}
			List<BountyPosting> list = _data.postings.Where((BountyPosting p) => p != null && p.acceptedBy == ownerId).ToList();
			if (list.Count == 0)
			{
				return "You have no active bounty.";
			}
			foreach (BountyPosting item in list)
			{
				item.acceptedBy = 0L;
				item.acceptedByName = null;
			}
			Save();
			if (list.Count != 1)
			{
				return $"{list.Count} bounties abandoned.";
			}
			return "Bounty abandoned.";
		}

		public static bool Remove(string postingId)
		{
			if (_data == null || string.IsNullOrEmpty(postingId))
			{
				return false;
			}
			int num = _data.postings.RemoveAll((BountyPosting p) => p != null && p.id == postingId);
			if (num > 0)
			{
				Save();
			}
			return num > 0;
		}

		public static void MarkSpawned(string postingId)
		{
			BountyPosting bountyPosting = Find(postingId);
			if (bountyPosting != null && !bountyPosting.spawned)
			{
				bountyPosting.spawned = true;
				Save();
			}
		}

		public static BountyPosting Find(string postingId)
		{
			return (_snapshot?.postings ?? new List<BountyPosting>()).FirstOrDefault((BountyPosting p) => p != null && p.id == postingId);
		}

		public static List<BountyPosting> All()
		{
			return (_snapshot?.postings ?? new List<BountyPosting>()).Where((BountyPosting p) => p != null).ToList();
		}

		public static List<BountyPosting> OpenPostings()
		{
			return (from p in All()
				where p.IsOpen
				orderby p.tier
				select p).ToList();
		}

		public static BountyPosting AcceptedBy(long ownerId)
		{
			if (ownerId != 0L)
			{
				return All().FirstOrDefault((BountyPosting p) => p.acceptedBy == ownerId);
			}
			return null;
		}

		public static void ClearAll()
		{
			if (_data != null)
			{
				_data.postings.Clear();
				Save();
			}
		}
	}
	public static class BountyFeatureGate
	{
		private const string ServerGuideGuid = "com.valheimserverguide";

		private const string DonationsGuid = "com.taeguk.valheimdonations";

		private static int _serverGuide = -1;

		private static int _donations = -1;

		private static bool _logged;

		public static bool ServerGuideLoaded => Probe(ref _serverGuide, "com.valheimserverguide", "serverguide");

		public static bool DonationsLoaded => Probe(ref _donations, "com.taeguk.valheimdonations", "valheimdonations");

		public static bool BiomeLordsLoaded => ContainerPanelPositioner.BiomeLordsLoaded();

		public static bool DependenciesPresent
		{
			get
			{
				if (BiomeLordsLoaded && ServerGuideLoaded)
				{
					return DonationsLoaded;
				}
				return false;
			}
		}

		public static bool IsServerAuthority
		{
			get
			{
				if ((Object)(object)ZNet.instance != (Object)null)
				{
					return ZNet.instance.IsServer();
				}
				return false;
			}
		}

		private static bool ConfigEnabled
		{
			get
			{
				if (Plugin.BountyEnabled != null)
				{
					return Plugin.BountyEnabled.Value;
				}
				return true;
			}
		}

		public static bool IsEnabled
		{
			get
			{
				if (ConfigEnabled && DependenciesPresent)
				{
					return IsServerAuthority;
				}
				return false;
			}
		}

		public static bool AvailableToLocalPlayer
		{
			get
			{
				if (!IsServerAuthority)
				{
					return BountySync.FeatureActive;
				}
				return IsEnabled;
			}
		}

		public static void LogDecisionOnce()
		{
			if (_logged)
			{
				return;
			}
			_logged = true;
			try
			{
				Plugin.Log.LogInfo((object)("[bounty] feature gate: " + (IsEnabled ? "ON" : "OFF") + " " + $"(BiomeLords={BiomeLordsLoaded}, ServerGuide={ServerGuideLoaded}, " + $"Donations={DonationsLoaded}, isServer={IsServerAuthority}, config={ConfigEnabled}). " + "All four must be true for bounty hunting to run."));
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[bounty] gate logging failed: " + ex.Message));
			}
		}

		private static bool Probe(ref int cache, string guid, string nameFragment)
		{
			if (cache < 0)
			{
				cache = 0;
				foreach (KeyValuePair<string, PluginInfo> pluginInfo in Chainloader.PluginInfos)
				{
					string text = pluginInfo.Key ?? string.Empty;
					PluginInfo value = pluginInfo.Value;
					object obj;
					if (value == null)
					{
						obj = null;
					}
					else
					{
						BepInPlugin metadata = value.Metadata;
						obj = ((metadata != null) ? metadata.Name : null);
					}
					if (obj == null)
					{
						obj = string.Empty;
					}
					string text2 = (string)obj;
					if (string.Equals(text, guid, StringComparison.OrdinalIgnoreCase) || text.IndexOf(nameFragment, StringComparison.OrdinalIgnoreCase) >= 0 || text2.IndexOf(nameFragment, StringComparison.OrdinalIgnoreCase) >= 0)
					{
						cache = 1;
						break;
					}
				}
			}
			return cache == 1;
		}
	}
	public static class BountyLeaderboardStore
	{
		private static BountyLadderData _data;

		private static BountyLadderData _snapshot = new BountyLadderData();

		private static string _loadedWorld;

		public static BountyLadderData Snapshot => _snapshot;

		private static string StorePath(string world)
		{
			return Path.Combine(LeaderboardStore.DataDir(), "bounty." + Sanitize(world) + ".json");
		}

		private static string Sanitize(string s)
		{
			if (string.IsNullOrEmpty(s))
			{
				return "world";
			}
			char[] invalidFileNameChars = Path.GetInvalidFileNameChars();
			foreach (char oldChar in invalidFileNameChars)
			{
				s = s.Replace(oldChar, '_');
			}
			return s;
		}

		private static string CurrentWorldName()
		{
			try
			{
				if ((Object)(object)ZNet.instance != (Object)null)
				{
					return ZNet.instance.GetWorldName();
				}
			}
			catch
			{
			}
			return "world";
		}

		public static void LoadForCurrentWorld()
		{
			string text = (_loadedWorld = CurrentWorldName());
			string text2 = StorePath(text);
			try
			{
				if (File.Exists(text2))
				{
					_data = CompetitiveJson.ReadBountyLadder(File.ReadAllText(text2)) ?? new BountyLadderData();
					if (_data.hunters == null)
					{
						_data.hunters = new List<BountyHunterRecord>();
					}
					Plugin.Log.LogInfo((object)$"[bounty] loaded {_data.hunters.Count} hunter record(s) for world '{text}'.");
				}
				else
				{
					_data = new BountyLadderData();
					Plugin.Log.LogInfo((object)("[bounty] no bounty ladder for world '" + text + "' — starting fresh."));
				}
			}
			catch (Exception ex)
			{
				_data = new BountyLadderData();
				Plugin.Log.LogWarning((object)("[bounty] failed to load '" + text2 + "': " + ex.Message + ". Starting fresh."));
			}
			_snapshot = _data;
		}

		public static void Save()
		{
			if (_data == null)
			{
				return;
			}
			try
			{
				File.WriteAllText(StorePath(_loadedWorld ?? CurrentWorldName()), CompetitiveJson.Write(_data, pretty: true));
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[bounty] ladder save failed: " + ex.Message));
			}
		}

		public static string SerializeSnapshot()
		{
			return CompetitiveJson.Write(_data ?? new BountyLadderData());
		}

		public static void ApplySnapshot(string json)
		{
			try
			{
				BountyLadderData bountyLadderData = CompetitiveJson.ReadBountyLadder(json) ?? new BountyLadderData();
				if (bountyLadderData.hunters == null)
				{
					bountyLadderData.hunters = new List<BountyHunterRecord>();
				}
				_snapshot = bountyLadderData;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[bounty] failed to apply ladder snapshot: " + ex.Message));
			}
		}

		public static bool ApplyResolution(long ownerId, string ownerName, int tier, string method, out int rank, out int points)
		{
			rank = 0;
			points = 0;
			if (_data == null)
			{
				_data = new BountyLadderData();
			}
			if (ownerId == 0L)
			{
				return false;
			}
			BountyHunterRecord bountyHunterRecord = _data.hunters.FirstOrDefault((BountyHunterRecord h) => h != null && h.ownerId == ownerId);
			if (bountyHunterRecord == null)
			{
				bountyHunterRecord = new BountyHunterRecord
				{
					ownerId = ownerId,
					seasonId = _data.seasonId
				};
				_data.hunters.Add(bountyHunterRecord);
			}
			if (!string.IsNullOrEmpty(ownerName))
			{
				bountyHunterRecord.ownerName = ownerName;
			}
			int num = Mathf.Max(1, Plugin.BountyPointsPerTier?.Value ?? 10) * BountyTiers.Clamp(tier);
			bountyHunterRecord.points += num;
			if (method == "communed")
			{
				bountyHunterRecord.communes++;
			}
			else
			{
				bountyHunterRecord.kills++;
			}
			if (tier > bountyHunterRecord.bestTier)
			{
				bountyHunterRecord.bestTier = BountyTiers.Clamp(tier);
			}
			bountyHunterRecord.lastResolvedTicks = DateTime.UtcNow.Ticks;
			Save();
			rank = RankOf(ownerId);
			points = bountyHunterRecord.points;
			return true;
		}

		public static List<BountyHunterRecord> Ranked()
		{
			return (from h in _snapshot?.hunters ?? new List<BountyHunterRecord>()
				where h != null
				orderby h.points descending, h.bestTier descending, h.ownerName ?? ""
				select h).ToList();
		}

		public static int RankOf(long ownerId)
		{
			if (ownerId == 0L)
			{
				return 0;
			}
			List<BountyHunterRecord> list = Ranked();
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i].ownerId == ownerId)
				{
					return i + 1;
				}
			}
			return 0;
		}

		public static BountyHunterRecord Find(long ownerId)
		{
			return (_snapshot?.hunters ?? new List<BountyHunterRecord>()).FirstOrDefault((BountyHunterRecord h) => h != null && h.ownerId == ownerId);
		}

		public static int SeasonReset()
		{
			if (_data == null)
			{
				return 0;
			}
			int count = _data.hunters.Count;
			try
			{
				string s = _loadedWorld ?? CurrentWorldName();
				File.WriteAllText(Path.Combine(LeaderboardStore.DataDir(), $"bounty.{Sanitize(s)}.season{_data.seasonId}.json"), CompetitiveJson.Write(_data, pretty: true));
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[bounty] season archive failed: " + ex.Message));
			}
			_data.seasonId++;
			_data.hunters.Clear();
			Save();
			_snapshot = _data;
			return count;
		}
	}
	public static class BountyLocationSampler
	{
		public static readonly Biome[] BountyBiomes;

		private const int RingPoints = 8;

		private const int Rings = 3;

		public static bool IsBountyBiome(Biome b)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			Biome[] bountyBiomes = BountyBiomes;
			foreach (Biome val in bountyBiomes)
			{
				if (b == val)
				{
					return true;
				}
			}
			return false;
		}

		public static bool TrySample(Vector3 origin, float minRadius, float maxRadius, out Vector3 pos, out Biome biome, out string stats)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Expected I4, but got Unknown
			pos = Vector3.zero;
			biome = (Biome)0;
			WorldGenerator instance = WorldGenerator.instance;
			if (instance == null)
			{
				stats = "WorldGenerator unavailable (no world loaded).";
				return false;
			}
			int num = Mathf.Max(1, Plugin.BountySampleAttempts?.Value ?? 200);
			float landRadius = Mathf.Max(8f, Plugin.BountyLandCheckRadius?.Value ?? 80f);
			float num2 = Mathf.Max(0f, Plugin.BountyWaterMargin?.Value ?? 3f);
			float num3 = Mathf.Max(1f, Plugin.BountyMaxHeightVariance?.Value ?? 10f);
			float num4 = WaterLevel();
			if (maxRadius < minRadius)
			{
				float num5 = minRadius;
				minRadius = maxRadius;
				maxRadius = num5;
			}
			int num6 = 0;
			int num7 = 0;
			int num8 = 0;
			int num9 = 0;
			for (int i = 0; i < num; i++)
			{
				float num10 = Random.value * (float)Math.PI * 2f;
				float num11 = Mathf.Sqrt(Mathf.Lerp(minRadius * minRadius, maxRadius * maxRadius, Random.value));
				float num12 = origin.x + Mathf.Cos(num10) * num11;
				float num13 = origin.z + Mathf.Sin(num10) * num11;
				Biome biome2 = instance.GetBiome(new Vector3(num12, 0f, num13));
				if (!IsBountyBiome(biome2))
				{
					num6++;
					continue;
				}
				float height = instance.GetHeight(num12, num13);
				if (height <= num4 + num2)
				{
					num7++;
					continue;
				}
				if (!SurroundedByLand(instance, num12, num13, landRadius, num4 + num2, out var innerMin, out var innerMax))
				{
					num8++;
					continue;
				}
				if (innerMax - innerMin > num3)
				{
					num9++;
					continue;
				}
				pos = new Vector3(num12, height, num13);
				biome = (Biome)(int)biome2;
				stats = $"found after {i + 1} attempt(s) " + $"(rejected: biome {num6}, water {num7}, island/coast {num8}, steep {num9}).";
				return true;
			}
			stats = $"no valid location in {num} attempts " + $"(rejected: biome {num6}, water {num7}, island/coast {num8}, steep {num9}).";
			return false;
		}

		private static bool SurroundedByLand(WorldGenerator wg, float cx, float cz, float landRadius, float minHeight, out float innerMin, out float innerMax)
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Invalid comparison between Unknown and I4
			innerMin = float.MaxValue;
			innerMax = float.MinValue;
			for (int i = 1; i <= 3; i++)
			{
				float num = landRadius * (float)i / 3f;
				for (int j = 0; j < 8; j++)
				{
					float num2 = (float)Math.PI * 2f * (float)j / 8f;
					float num3 = cx + Mathf.Cos(num2) * num;
					float num4 = cz + Mathf.Sin(num2) * num;
					if (wg.GetHeight(num3, num4) <= minHeight)
					{
						return false;
					}
					if ((int)wg.GetBiome(new Vector3(num3, 0f, num4)) == 256)
					{
						return false;
					}
					if (i == 1)
					{
						float height = wg.GetHeight(num3, num4);
						if (height < innerMin)
						{
							innerMin = height;
						}
						if (height > innerMax)
						{
							innerMax = height;
						}
					}
				}
			}
			if (innerMin > innerMax)
			{
				innerMin = (innerMax = 0f);
			}
			return true;
		}

		public static float WaterLevel()
		{
			if (!((Object)(object)ZoneSystem.instance != (Object)null))
			{
				return 30f;
			}
			return ZoneSystem.instance.m_waterLevel;
		}

		public static int SampleMany(Vector3 origin, float minRadius, float maxRadius, int count, List<(Vector3 pos, Biome biome)> into, out string report)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			StringBuilder stringBuilder = new StringBuilder();
			int num = 0;
			for (int i = 0; i < count; i++)
			{
				if (TrySample(origin, minRadius, maxRadius, out var pos, out var biome, out var stats))
				{
					into.Add((pos, biome));
					num++;
					stringBuilder.AppendLine($"  #{num} {biome} at ({pos.x:F0}, {pos.z:F0}) height {pos.y:F1} — {stats}");
				}
				else
				{
					stringBuilder.AppendLine("  (failed) " + stats);
				}
			}
			report = stringBuilder.ToString();
			return num;
		}

		static BountyLocationSampler()
		{
			Biome[] array = new Biome[4];
			RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
			BountyBiomes = (Biome[])(object)array;
		}
	}
	public static class BountyMapPin
	{
		private static readonly Dictionary<string, PinData> _pins = new Dictionary<string, PinData>();

		private static Minimap _boundMap;

		private const PinType BountyPinType = (PinType)9;

		public static int Count => _pins.Count;

		private static bool SyncMap(out Minimap map)
		{
			map = Minimap.instance;
			if ((Object)(object)map == (Object)null)
			{
				_pins.Clear();
				_boundMap = null;
				return false;
			}
			if ((Object)(object)_boundMap != (Object)(object)map)
			{
				_pins.Clear();
				_boundMap = map;
			}
			return true;
		}

		public static void Show(string bountyId, string label, Vector3 pos)
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(bountyId) || !SyncMap(out var map))
			{
				return;
			}
			string text = (string.IsNullOrEmpty(label) ? "Bounty" : label);
			if (_pins.TryGetValue(bountyId, out var value) && value != null)
			{
				value.m_pos = pos;
				if (value.m_name != text)
				{
					value.m_name = text;
				}
				Style(value);
			}
			else
			{
				value = map.AddPin(pos, (PinType)9, text, false, false, 0L, default(PlatformUserID));
				_pins[bountyId] = value;
				Style(value);
				Plugin.Log.LogInfo((object)$"[bounty] pinned '{text}' at ({pos.x:F0}, {pos.z:F0}).");
			}
		}

		public static void Remove(string bountyId)
		{
			if (!string.IsNullOrEmpty(bountyId) && SyncMap(out var map) && _pins.TryGetValue(bountyId, out var value))
			{
				if (value != null)
				{
					map.RemovePin(value);
				}
				_pins.Remove(bountyId);
				Plugin.Log.LogInfo((object)("[bounty] pin removed for bounty '" + bountyId + "'."));
			}
		}

		public static void ClearAll()
		{
			if (!SyncMap(out var map))
			{
				return;
			}
			foreach (KeyValuePair<string, PinData> pin in _pins)
			{
				if (pin.Value != null)
				{
					map.RemovePin(pin.Value);
				}
			}
			_pins.Clear();
		}

		private static void Style(PinData pin)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			Image val = pin?.m_iconElement;
			if (!((Object)(object)val == (Object)null))
			{
				((Graphic)val).color = new Color(1f, 0.35f, 0.3f);
			}
		}
	}
	[HarmonyPatch(typeof(Character), "GetHoverName")]
	public static class BountyNameBadgePatch
	{
		private const string TargetColor = "#FF6B4A";

		private const string EscortColor = "#FFA07A";

		public static void Postfix(Character __instance, ref string __result)
		{
			BountyTarget bountyTarget = (((Object)(object)__instance != (Object)null) ? ((Component)__instance).GetComponent<BountyTarget>() : null);
			if (!((Object)(object)bountyTarget == (Object)null) && !((Object)(object)((Component)__instance).GetComponent<DvergrCompanion>() != (Object)null))
			{
				if (bountyTarget.IsMinion)
				{
					__result += "  <color=#FFA07A>[Escort]</color>";
				}
				else
				{
					__result += string.Format("  <color={0}>[T{1} {2} Bounty]</color>", "#FF6B4A", bountyTarget.Tier, BountyTiers.TierName(bountyTarget.Tier));
				}
			}
		}
	}
	[Serializable]
	public class BountyPosting
	{
		public string id;

		public int tier;

		public int biome;

		public float x;

		public float y;

		public float z;

		public long acceptedBy;

		public string acceptedByName;

		public bool spawned;

		public long postedTicks;

		public bool tutorial;

		public bool IsOpen => acceptedBy == 0;

		public Vector3 Position => new Vector3(x, y, z);

		public Biome Biome => (Biome)biome;

		public string Label => $"{BountyTiers.TierName(tier)} bounty ({Biome})";
	}
	[Serializable]
	public class BountyBoardData
	{
		public List<BountyPosting> postings = new List<BountyPosting>();
	}
	public static class BountyQuestGate
	{
		public const string KeyStartRequested = "LS_BountyStart";

		public const string KeyUnlocked = "LS_BountyUnlocked";

		public const string TutorialPostingTag = "tutorial";

		public static bool IsUnlocked(Player player)
		{
			if ((Object)(object)player != (Object)null)
			{
				return ((Humanoid)player).HaveUniqueKey("LS_BountyUnlocked");
			}
			return false;
		}

		public static bool HasPendingStart(Player player)
		{
			if ((Object)(object)player != (Object)null)
			{
				return ((Humanoid)player).HaveUniqueKey("LS_BountyStart");
			}
			return false;
		}

		public static void Unlock(Player player)
		{
			if (!((Object)(object)player == (Object)null) && !((Humanoid)player).HaveUniqueKey("LS_BountyUnlocked"))
			{
				((Humanoid)player).AddUniqueKey("LS_BountyUnlocked");
				((Humanoid)player).RemoveUniqueKey("LS_BountyStart");
				Plugin.Log.LogInfo((object)("[bounty] " + player.GetPlayerName() + " has completed the warden's commission — the board is open to them."));
			}
		}

		public static bool ConsumeStartRequest(Player player)
		{
			if ((Object)(object)player == (Object)null || !((Humanoid)player).HaveUniqueKey("LS_BountyStart"))
			{
				return false;
			}
			((Humanoid)player).RemoveUniqueKey("LS_BountyStart");
			return true;
		}

		public static void Reset(Player player)
		{
			if (!((Object)(object)player == (Object)null))
			{
				((Humanoid)player).RemoveUniqueKey("LS_BountyUnlocked");
				((Humanoid)player).RemoveUniqueKey("LS_BountyStart");
			}
		}
	}
	[Serializable]
	public class BountyHunterRecord
	{
		public long ownerId;

		public string ownerName;

		public int points;

		public int kills;

		public int communes;

		public int bestTier;

		public long lastResolvedTicks;

		public int seasonId = 1;

		public int Total => kills + communes;
	}
	[Serializable]
	public class BountyLadderData
	{
		public int seasonId = 1;

		public List<BountyHunterRecord> hunters = new List<BountyHunterRecord>();
	}
	public static class BountyService
	{
		public const string MethodKilled = "killed";

		public const string MethodCommuned = "communed";

		private static readonly HashSet<string> _resolved = new HashSet<string>();

		public static void NotifyKilled(Character dead, Player credit)
		{
			Resolve(dead, credit, "killed");
		}

		public static void NotifyCommuned(Character freed, Player credit)
		{
			Resolve(freed, credit, "communed");
		}

		private static void Resolve(Character character, Player credit, string method)
		{
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)character == (Object)null)
			{
				return;
			}
			BountyTarget component = ((Component)character).GetComponent<BountyTarget>();
			if ((Object)(object)component == (Object)null || component.IsMinion)
			{
				return;
			}
			string bountyId = component.BountyId;
			if (string.IsNullOrEmpty(bountyId) || _resolved.Contains(bountyId))
			{
				return;
			}
			_resolved.Add(bountyId);
			BountyMapPin.Remove(bountyId);
			int num = EffectiveTier(component.Tier, credit);
			string text = BountyTiers.TierName(num);
			string text2 = ((WorldGenerator.instance != null) ? ((object)WorldGenerator.instance.GetBiome(((Component)character).transform.position)/*cast due to .constrained prefix*/).ToString() : string.Empty);
			Plugin.Log.LogInfo((object)("[bounty] '" + bountyId + "' resolved by " + method + " " + $"(tier {component.Tier} -> effective {num}, {text2}) " + "for " + (((Object)(object)credit != (Object)null) ? credit.GetPlayerName() : "?") + "."));
			ServerGuideBridge.RaiseBountyResolved(num, text, text2, method);
			TryAwardValcoin(num, text, credit);
			if ((Object)(object)credit != (Object)null)
			{
				BountySync.ReportResolution(credit.GetPlayerID(), credit.GetPlayerName(), component.Tier, method, bountyId);
			}
			if ((Object)(object)credit != (Object)null && (Object)(object)MessageHud.instance != (Object)null && (Object)(object)credit == (Object)(object)Player.m_localPlayer)
			{
				MessageHud.instance.ShowMessage((MessageType)2, (method == "communed") ? ("The " + text + " bounty is answered — freed, not felled.") : ("The " + text + " bounty is answered."), 0, (Sprite)null, false);
			}
			if ((Object)(object)credit != (Object)null && (Object)(object)credit == (Object)(object)Player.m_localPlayer && BountyBoardStore.IsTutorial(bountyId))
			{
				BountyQuestGate.Unlock(credit);
				if ((Object)(object)MessageHud.instance != (Object)null)
				{
					MessageHud.instance.ShowMessage((MessageType)2, "The warden will hear of this. The Wanted Board is open to you.", 0, (Sprite)null, false);
				}
			}
		}

		private static int EffectiveTier(int baseTier, Player credit)
		{
			int num = BountyLeaderboardBonus(credit);
			int num2 = Mathf.Max(0, Plugin.BountyMaxTierBonus?.Value ?? 1);
			return BountyTiers.Clamp(baseTier + Mathf.Clamp(num, 0, num2));
		}

		private static int BountyLeaderboardBonus(Player credit)
		{
			if ((Object)(object)credit == (Object)null)
			{
				return 0;
			}
			int num = Mathf.Max(0, Plugin.BountyLeaderboardBonusRank?.Value ?? 3);
			if (num <= 0)
			{
				return 0;
			}
			int num2 = BountyLeaderboardStore.RankOf(credit.GetPlayerID());
			if (num2 <= 0 || num2 > num)
			{
				return 0;
			}
			return 1;
		}

		private static void TryAwardValcoin(int tier, string tierName, Player credit)
		{
			if ((Object)(object)credit == (Object)null || !BountyFeatureGate.DonationsLoaded)
			{
				return;
			}
			float num = ValcoinChanceFor(credit, tier);
			if (!(num <= 0f))
			{
				float value = Random.value;
				bool flag = value < num;
				Plugin.Log.LogInfo((object)("[bounty] valcoin roll for " + credit.GetPlayerName() + ": " + string.Format("{0:F2} vs chance {1:F2} (tier {2}) => {3}.", value, num, tier, flag ? "PAID" : "no payout")));
				if (flag)
				{
					ServerGuideBridge.RaiseBountyValcoin(tier, tierName);
				}
			}
		}

		public static float ValcoinChanceFor(Player player, int tier)
		{
			float num = Plugin.BountyValcoinBaseChance?.Value ?? 0.1f;
			float num2 = Plugin.BountyValcoinChancePerTier?.Value ?? 0.05f;
			float num3 = Plugin.BountyValcoinRankBonus?.Value ?? 0.25f;
			float num4 = Plugin.BountyValcoinMaxChance?.Value ?? 0.75f;
			float num5 = num + num2 * (float)(BountyTiers.Clamp(tier) - 1);
			int num6 = BestCompetitiveRank(player);
			int num7 = Mathf.Max(1, Plugin.BountyValcoinRankDepth?.Value ?? 10);
			if (num6 > 0 && num6 <= num7)
			{
				num5 += num3 * (1f - (float)(num6 - 1) / (float)num7);
			}
			return Mathf.Clamp(num5, 0f, Mathf.Clamp01(num4));
		}

		public static bool IsEliteEligible(long ownerId)
		{
			int num = Plugin.BountyEliteRankTopN?.Value ?? 10;
			if (num <= 0)
			{
				return true;
			}
			int num2 = BestCompetitiveRankFor(ownerId);
			if (num2 > 0)
			{
				return num2 <= num;
			}
			return false;
		}

		public static int BestCompetitiveRank(Player player)
		{
			if (!((Object)(object)player == (Object)null))
			{
				return BestCompetitiveRankFor(player.GetPlayerID());
			}
			return 0;
		}

		public static int BestCompetitiveRankFor(long ownerId)
		{
			if (ownerId == 0L)
			{
				return 0;
			}
			int num = 0;
			List<CompanionRecord> list = LeaderboardStore.Ranked();
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i] != null && list[i].ownerId == ownerId)
				{
					num = i + 1;
					break;
				}
			}
			List<PartyRecord> list2 = LeaderboardStore.RankedParties();
			for (int j = 0; j < list2.Count; j++)
			{
				if (list2[j] != null && list2[j].ownerId == ownerId)
				{
					int num2 = j + 1;
					if (num == 0 || num2 < num)
					{
						num = num2;
					}
					break;
				}
			}
			return num;
		}

		public static void ResetSession()
		{
			_resolved.Clear();
		}
	}
	[HarmonyPatch(typeof(Character), "OnDeath")]
	public static class BountyDeathPatch
	{
		public static void Prefix(Character __instance)
		{
			if (!((Object)(object)__instance == (Object)null) && !((Object)(object)((Component)__instance).GetComponent<BountyTarget>() == (Object)null))
			{
				BountyService.NotifyKilled(__instance, Player.m_localPlayer);
			}
		}
	}
	public static class BountySpawner
	{
		public class SpawnedBounty
		{
			public string BountyId;

			public int Tier;

			public Biome Biome;

			public Vector3 Position;

			public GameObject Target;

			public readonly List<GameObject> Minions = new List<GameObject>();
		}

		private static readonly string[] MeleePrefabs = new string[1] { "Dverger" };

		private static readonly string[] MagePrefabs = new string[3] { "DvergerMageFire", "DvergerMageIce", "DvergerMageSupport" };

		public static SpawnedBounty Spawn(string bountyId, int tier, Vector3 pos, Biome biome)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ZNetScene.instance == (Object)null)
			{
				return null;
			}
			tier = BountyTiers.Clamp(tier);
			SpawnedBounty spawnedBounty = new SpawnedBounty
			{
				BountyId = bountyId,
				Tier = tier,
				Biome = biome,
				Position = pos
			};
			spawnedBounty.Target = SpawnOne(bountyId, tier, pos, minion: false, tier);
			if ((Object)(object)spawnedBounty.Target == (Object)null)
			{
				Plugin.Log.LogWarning((object)("[bounty] could not spawn target for '" + bountyId + "' — no Dvergr prefab."));
				return null;
			}
			int num = BountyTiers.MinionCount(tier);
			float num2 = Mathf.Max(2f, Plugin.BountyMinionRingRadius?.Value ?? 6f);
			for (int i = 0; i < num; i++)
			{
				float num3 = (float)Math.PI * 2f * (float)i / (float)Mathf.Max(1, num) + Random.value * 0.4f;
				Vector3 val = pos + new Vector3(Mathf.Cos(num3), 0f, Mathf.Sin(num3)) * num2;
				val.y = GroundHeight(val, pos.y);
				GameObject val2 = SpawnOne(bountyId, BountyTiers.MinionTier(tier), val, minion: true, tier);
				if ((Object)(object)val2 != (Object)null)
				{
					spawnedBounty.Minions.Add(val2);
				}
			}
			Plugin.Log.LogInfo((object)($"[bounty] spawned '{bountyId}' — {BountyTiers.Describe(tier)} in {biome} " + $"at ({pos.x:F0}, {pos.z:F0}); escort {spawnedBounty.Minions.Count}/{num}."));
			return spawnedBounty;
		}

		private static GameObject SpawnOne(string bountyId, int tier, Vector3 pos, bool minion, int tierForPick)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			GameObject prefab = ZNetScene.instance.GetPrefab(PickPrefab(tierForPick, minion));
			if ((Object)(object)prefab == (Object)null)
			{
				prefab = ZNetScene.instance.GetPrefab("Dverger");
			}
			if ((Object)(object)prefab == (Object)null)
			{
				return null;
			}
			GameObject val = Object.Instantiate<GameObject>(prefab, pos, Quaternion.Euler(0f, Random.value * 360f, 0f));
			BountyTarget.Stamp(val, bountyId, minion ? tier : tier, minion);
			Character component = val.GetComponent<Character>();
			if ((Object)(object)component != (Object)null)
			{
				component.SetLevel(BountyTiers.StarLevel(tier));
			}
			if ((Object)(object)val.GetComponent<BountyTarget>() == (Object)null)
			{
				val.AddComponent<BountyTarget>();
			}
			return val;
		}

		private static string PickPrefab(int tier, bool minion)
		{
			float num = Mathf.Clamp01((float)(BountyTiers.Clamp(tier) - 1) * 0.25f);
			if (minion)
			{
				num *= 0.6f;
			}
			if (!(Random.value < num))
			{
				return MeleePrefabs[Random.Range(0, MeleePrefabs.Length)];
			}
			return MagePrefabs[Random.Range(0, MagePrefabs.Length)];
		}

		private static float GroundHeight(Vector3 p, float fallback)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			float result = default(float);
			if ((Object)(object)ZoneSystem.instance != (Object)null && ZoneSystem.instance.GetSolidHeight(p, ref result, 1000))
			{
				return result;
			}
			if (WorldGenerator.instance != null)
			{
				return WorldGenerator.instance.GetHeight(p.x, p.z);
			}
			return fallback;
		}
	}
	[HarmonyPatch(typeof(MonsterAI), "Start")]
	public static class BountyTargetRestorePatch
	{
		public static void Postfix(MonsterAI __instance)
		{
			GameObject val = (((Object)(object)__instance != (Object)null) ? ((Component)__instance).gameObject : null);
			if (!((Object)(object)val == (Object)null) && !((Object)(object)val.GetComponent<BountyTarget>() != (Object)null))
			{
				ZNetView component = val.GetComponent<ZNetView>();
				if (!((Object)(object)component == (Object)null) && component.IsValid() && !string.IsNullOrEmpty(component.GetZDO().GetString("DE_BountyId", (string)null)) && !((Object)(object)val.GetComponent<DvergrCompanion>() != (Object)null))
				{
					val.AddComponent<BountyTarget>();
				}
			}
		}
	}
	public static class BountySync
	{
		[HarmonyPatch(typeof(ZNet), "Awake")]
		private static class ZNetAwakePatch
		{
			private static void Postfix(ZNet __instance)
			{
				EnsureRegistered();
				BountyService.ResetSession();
				if (__instance.IsServer())
				{
					BountyFeatureGate.LogDecisionOnce();
					BountyLeaderboardStore.LoadForCurrentWorld();
					BountyBoardStore.LoadForCurrentWorld();
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "OnDestroy")]
		private static class ZNetOnDestroyPatch
		{
			private static void Postfix()
			{
				_bound = false;
				FeatureActive = false;
			}
		}

		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		private static class PeerInfoPatch
		{
			private static void Postfix(ZNet __instance, ZRpc rpc)
			{
				if (__instance.IsServer())
				{
					ZNetPeer peer = __instance.GetPeer(rpc);
					if (peer != null)
					{
						EnsureRegistered();
						SendFeatureStateToPeer(peer.m_uid);
						SendLadderToPeer(peer.m_uid);
						SendBoardToPeer(peer.m_uid);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Player), "OnSpawned")]
		private static class PlayerSpawnedPatch
		{
			private static void Postfix(Player __instance)
			{
				if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
				{
					RequestFeatureState();
					RequestLadder();
					RequestBoard();
				}
			}
		}

		private const string RpcBountyActive = "LSII_BountyActive";

		private const string RpcBountyRequest = "LSII_BountyReq";

		private const string RpcBountyReport = "LSII_BountyRep";

		private const string RpcBountyPush = "LSII_BountyPush";

		private const string RpcBountyLadderReq = "LSII_BountyLadReq";

		private const string RpcBoardPush = "LSII_BoardPush";

		private const string RpcBoardReq = "LSII_BoardReq";

		private const string RpcBoardAccept = "LSII_BoardAccept";

		private const string RpcBoardAbandon = "LSII_BoardAband";

		private const string RpcBoardSpawned = "LSII_BoardSpawned";

		private const string RpcBoardAck = "LSII_BoardAck";

		private const string RpcBoardCommission = "LSII_BoardComm";

		private static bool _bound;

		public static bool FeatureActive { get; private set; }

		private static void EnsureRegistered()
		{
			if (!_bound && ZRoutedRpc.instance != null)
			{
				ZRoutedRpc.instance.Register<string>("LSII_BountyActive", (Action<long, string>)OnBountyActive);
				ZRoutedRpc.instance.Register<string>("LSII_BountyReq", (Action<long, string>)OnBountyRequest);
				ZRoutedRpc.instance.Register<string>("LSII_BountyRep", (Action<long, string>)OnBountyReport);
				ZRoutedRpc.instance.Register<ZPackage>("LSII_BountyPush", (Action<long, ZPackage>)OnBountyPush);
				ZRoutedRpc.instance.Register<string>("LSII_BountyLadReq", (Action<long, string>)OnBountyLadderRequest);
				ZRoutedRpc.instance.Register<ZPackage>("LSII_BoardPush", (Action<long, ZPackage>)OnBoardPush);
				ZRoutedRpc.instance.Register<string>("LSII_BoardReq", (Action<long, string>)OnBoardRequest);
				ZRoutedRpc.instance.Register<string>("LSII_BoardAccept", (Action<long, string>)OnBoardAccept);
				ZRoutedRpc.instance.Register<string>("LSII_BoardAband", (Action<long, string>)OnBoardAbandon);
				ZRoutedRpc.instance.Register<string>("LSII_BoardSpawned", (Action<long, string>)OnBoardSpawned);
				ZRoutedRpc.instance.Register<string>("LSII_BoardAck", (Action<long, string>)OnBoardAck);
				ZRoutedRpc.instance.Register<string>("LSII_BoardComm", (Action<long, string>)OnBoardCommission);
				_bound = true;
				Plugin.Log.LogInfo((object)"[bounty] RPCs registered.");
			}
		}

		public static void SendFeatureStateToPeer(long peer)
		{
			if (ZRoutedRpc.instance != null && BountyFeatureGate.IsServerAuthority)
			{
				ZRoutedRpc.instance.InvokeRoutedRPC(peer, "LSII_BountyActive", new object[1] { BountyFeatureGate.IsEnabled ? "1" : "0" });
			}
		}

		public static void BroadcastFeatureState()
		{
			if (ZRoutedRpc.instance != null && BountyFeatureGate.IsServerAuthority)
			{
				ZRoutedRpc.instance.InvokeRoutedRPC(0L, "LSII_BountyActive", new object[1] { BountyFeatureGate.IsEnabled ? "1" : "0" });
			}
		}

		private static void OnBountyActive(long sender, string value)
		{
			if (!BountyFeatureGate.IsServerAuthority)
			{
				bool flag = value == "1";
				if (flag != FeatureActive)
				{
					FeatureActive = flag;
					Plugin.Log.LogInfo((object)("[bounty] server reports bounty hunting " + (flag ? "ACTIVE" : "unavailable") + "."));
				}
			}
		}

		public static void RequestFeatureState()
		{
			if (ZRoutedRpc.instance != null && !BountyFeatureGate.IsServerAuthority)
			{
				ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), "LSII_BountyReq", new object[1] { string.Empty });
			}
		}

		private static void OnBountyRequest(long sender, string _)
		{
			if (BountyFeatureGate.IsServerAuthority)
			{
				SendFeatureStateToPeer(sender);
			}
		}

		public static void ReportResolution(long ownerId, string ownerName, int tier, string method, string bountyId = null)
		{
			if (ZRoutedRpc.instance != null)
			{
				string text = string.Join("|", ownerId.ToString(), S(ownerName), tier.ToString(), S(method), S(bountyId));
				if (BountyFeatureGate.IsServerAuthority)
				{
					ApplyReport(text);
					return;
				}
				ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), "LSII_BountyRep", new object[1] { text });
			}
			static string S(string s)
			{
				return (s ?? string.Empty).Replace('|', '/');
			}
		}

		private static void OnBountyReport(long sender, string payload)
		{
			ApplyReport(payload);
		}

		private static void ApplyReport(string payload)
		{
			if (!BountyFeatureGate.IsServerAuthority || !BountyFeatureGate.IsEnabled)
			{
				return;
			}
			string[] array = (payload ?? string.Empty).Split(new char[1] { '|' });
			if (array.Length < 4)
			{
				return;
			}
			long.TryParse(array[0], out var result);
			int.TryParse(array[2], out var result2);
			if (BountyLeaderboardStore.ApplyResolution(result, array[1], result2, array[3], out var rank, out var points))
			{
				Plugin.Log.LogInfo((object)($"[bounty] ladder: '{array[1]}' answered a tier {result2} bounty ({array[3]}) " + $"— {points} points, rank #{rank}."));
				BroadcastLadder();
				if (array.Length > 4 && !string.IsNullOrEmpty(array[4]) && BountyBoardStore.Remove(array[4]))
				{
					BroadcastBoard();
				}
			}
		}

		public static void BroadcastLadder()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Expected O, but got Unknown
			if (ZRoutedRpc.instance != null && BountyFeatureGate.IsServerAuthority)
			{
				ZPackage val = new ZPackage();
				val.Write(BountyLeaderboardStore.SerializeSnapshot());
				ZRoutedRpc.instance.InvokeRoutedRPC(0L, "LSII_BountyPush", new object[1] { val });
			}
		}

		public static void SendLadderToPeer(long peer)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Expected O, but got Unknown
			if (ZRoutedRpc.instance != null && BountyFeatureGate.IsServerAuthority)
			{
				ZPackage val = new ZPackage();
				val.Write(BountyLeaderboardStore.SerializeSnapshot());
				ZRoutedRpc.instance.InvokeRoutedRPC(peer, "LSII_BountyPush", new object[1] { val });
			}
		}

		private static void OnBountyPush(long sender, ZPackage pkg)
		{
			if (!BountyFeatureGate.IsServerAuthority)
			{
				BountyLeaderboardStore.ApplySnapshot(pkg.ReadString());
			}
		}

		public static void RequestLadder()
		{
			if (ZRoutedRpc.instance != null && !BountyFeatureGate.IsServerAuthority)
			{
				ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), "LSII_BountyLadReq", new object[1] { string.Empty });
			}
		}

		private static void OnBountyLadderRequest(long sender, string _)
		{
			if (BountyFeatureGate.IsServerAuthority)
			{
				SendLadderToPeer(sender);
			}
		}

		public static void BroadcastBoard()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Expected O, but got Unknown
			if (ZRoutedRpc.instance != null && BountyFeatureGate.IsServerAuthority)
			{
				ZPackage val = new ZPackage();
				val.Write(BountyBoardStore.SerializeSnapshot());
				ZRoutedRpc.instance.InvokeRoutedRPC(0L, "LSII_BoardPush", new object[1] { val });
			}
		}

		public static void SendBoardToPeer(long peer)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Expected O, but got Unknown
			if (ZRoutedRpc.instance != null && BountyFeatureGate.IsServerAuthority)
			{
				ZPackage val = new ZPackage();
				val.Write(BountyBoardStore.SerializeSnapshot());
				ZRoutedRpc.instance.InvokeRoutedRPC(peer, "LSII_BoardPush", new object[1] { val });
			}
		}

		private static void OnBoardPush(long sender, ZPackage pkg)
		{
			if (!BountyFeatureGate.IsServerAuthority)
			{
				BountyBoardStore.ApplySnapshot(pkg.ReadString());
			}
		}

		public static void RequestBoard()
		{
			if (ZRoutedRpc.instance != null && !BountyFeatureGate.IsServerAuthority)
			{
				ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), "LSII_BoardReq", new object[1] { string.Empty });
			}
		}

		private static void OnBoardRequest(long sender, string _)
		{
			if (BountyFeatureGate.IsServerAuthority)
			{
				SendBoardToPeer(sender);
			}
		}

		public static void SendAccept(string postingId)
		{
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null) && ZRoutedRpc.instance != null)
			{
				string text = string.Join("|", localPlayer.GetPlayerID().ToString(), S(localPlayer.GetPlayerName()), S(postingId));
				if (BountyFeatureGate.IsServerAuthority)
				{
					ShowLocal(ApplyAccept(text));
					return;
				}
				ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), "LSII_BoardAccept", new object[1] { text });
			}
			static string S(string s)
			{
				return (s ?? string.Empty).Replace('|', '/');
			}
		}

		private static void OnBoardAccept(long sender, string payload)
		{
			if (BountyFeatureGate.IsServerAuthority)
			{
				string text = ApplyAccept(payload);
				if (!string.IsNullOrEmpty(text))
				{
					ZRoutedRpc.instance.InvokeRoutedRPC(sender, "LSII_BoardAck", new object[1] { text });
				}
			}
		}

		private static string ApplyAccept(string payload)
		{
			if (!BountyFeatureGate.IsEnabled)
			{
				return "Bounty hunting isn't active here.";
			}
			string[] array = (payload ?? string.Empty).Split(new char[1] { '|' });
			if (array.Length < 3)
			{
				return null;
			}
			long.TryParse(array[0], out var result);
			string result2 = BountyBoardStore.Accept(result, array[1], array[2]);
			BroadcastBoard();
			return result2;
		}

		public static void SendAbandon()
		{
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null) && ZRoutedRpc.instance != null)
			{
				string text = localPlayer.GetPlayerID().ToString();
				if (BountyFeatureGate.IsServerAuthority)
				{
					ShowLocal(ApplyAbandon(text));
					return;
				}
				ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), "LSII_BoardAband", new object[1] { text });
			}
		}

		private static void OnBoardAbandon(long sender, string payload)
		{
			if (BountyFeatureGate.IsServerAuthority)
			{
				string text = ApplyAbandon(payload);
				if (!string.IsNullOrEmpty(text))
				{
					ZRoutedRpc.instance.InvokeRoutedRPC(sender, "LSII_BoardAck", new object[1] { text });
				}
			}
		}

		private static string ApplyAbandon(string payload)
		{
			long.TryParse(payload, out var result);
			string result2 = BountyBoardStore.Abandon(result);
			BroadcastBoard();
			return result2;
		}

		public static void SendSpawned(string postingId)
		{
			if (ZRoutedRpc.instance != null)
			{
				if (BountyFeatureGate.IsServerAuthority)
				{
					ApplySpawned(postingId);
					return;
				}
				ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), "LSII_BoardSpawned", new object[1] { postingId ?? string.Empty });
			}
		}

		private static void OnBoardSpawned(long sender, string postingId)
		{
			ApplySpawned(postingId);
		}

		private static void ApplySpawned(string postingId)
		{
			if (BountyFeatureGate.IsServerAuthority)
			{
				BountyBoardStore.MarkSpawned(postingId);
				BroadcastBoard();
			}
		}

		public static void SendCommissionRequest(Vector3 near)
		{
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null) && ZRoutedRpc.instance != null)
			{
				string text = string.Join("|", localPlayer.GetPlayerID().ToString(), S(localPlayer.GetPlayerName()), near.x.ToString(CultureInfo.InvariantCulture), near.z.ToString(CultureInfo.InvariantCulture));
				if (BountyFeatureGate.IsServerAuthority)
				{
					ShowLocal(ApplyCommission(text));
					return;
				}
				ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), "LSII_BoardComm", new object[1] { text });
			}
			static string S(string s)
			{
				return (s ?? string.Empty).Replace('|', '/');
			}
		}

		private static void OnBoardCommission(long sender, string payload)
		{
			if (BountyFeatureGate.IsServerAuthority)
			{
				string text = ApplyCommission(payload);
				if (!string.IsNullOrEmpty(text))
				{
					ZRoutedRpc.instance.InvokeRoutedRPC(sender, "LSII_BoardAck", new object[1] { text });
				}
			}
		}

		private static string ApplyCommission(string payload)
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			if (!BountyFeatureGate.IsEnabled)
			{
				return "Bounty hunting isn't active here.";
			}
			string[] array = (payload ?? string.Empty).Split(new char[1] { '|' });
			if (array.Length < 4)
			{
				return null;
			}
			long.TryParse(array[0], out var result);
			float.TryParse(array[2], NumberStyles.Float, CultureInfo.InvariantCulture, out var result2);
			float.TryParse(array[3], NumberStyles.Float, CultureInfo.InvariantCulture, out var result3);
			BountyPosting created;
			string result4 = BountyBoardStore.CreateTutorial(result, array[1], new Vector3(result2, 0f, result3), out created);
			BroadcastBoard();
			return result4;
		}

		private static void OnBoardAck(long sender, string msg)
		{
			ShowLocal(msg);
		}

		private static void ShowLocal(string msg)
		{
			if (!string.IsNullOrEmpty(msg) && (Object)(object)MessageHud.instance != (Object)null)
			{
				MessageHud.instance.ShowMessage((MessageType)2, msg, 0, (Sprite)null, false);
			}
		}
	}
	public class BountyTarget : MonoBehaviour
	{
		public const string ZdoKeyBountyId = "DE_BountyId";

		public const string ZdoKeyBountyTier = "DE_BountyTier";

		public const string ZdoKeyBountyMinion = "DE_BountyMinion";

		public const string ZdoKeyBountyInit = "DE_BountyInit";

		private const float EnforceInterval = 3f;

		private Character _character;

		private MonsterAI _ai;

		private ZNetView _znv;

		private float _timer;

		private bool _standDown;

		private float _baseAlertRange;

		public string BountyId { get; private set; }

		public int Tier { get; private set; } = 1;

		public bool IsMinion { get; private set; }

		private void Awake()
		{
			_character = ((Component)this).GetComponent<Character>();
			_ai = ((Component)this).GetComponent<MonsterAI>();
			_znv = ((Component)this).GetComponent<ZNetView>();
			if ((Object)(object)_znv == (Object)null || !_znv.IsValid())
			{
				((Behaviour)this).enabled = false;
				return;
			}
			ZDO zDO = _znv.GetZDO();
			BountyId = zDO.GetString("DE_BountyId", (string)null);
			Tier = zDO.GetInt("DE_BountyTier", 1);
			IsMinion = zDO.GetBool("DE_BountyMinion", false);
			if (string.IsNullOrEmpty(BountyId))
			{
				((Behaviour)this).enabled = false;
				return;
			}
			ApplyScaling();
			ApplyAggression();
		}

		private void Update()
		{
			if (_standDown)
			{
				return;
			}
			_timer += Time.deltaTime;
			if (!(_timer < 3f))
			{
				_timer = 0f;
				if ((Object)(object)_character == (Object)null || _character.IsDead() || (Object)(object)((Component)this).GetComponent<DvergrCompanion>() != (Object)null)
				{
					StandDown();
				}
				else
				{
					ApplyAggression();
				}
			}
		}

		private void ApplyScaling()
		{
			if (!((Object)(object)_character == (Object)null) && !((Object)(object)_znv == (Object)null) && _znv.IsOwner())
			{
				ZDO zDO = _znv.GetZDO();
				float num = (IsMinion ? BountyTiers.HealthMultiplier(BountyTiers.MinionTier(Tier)) : BountyTiers.HealthMultiplier(Tier));
				float health = _character.GetHealth();
				bool num2 = !zDO.GetBool("DE_BountyInit", false);
				_character.SetMaxHealth(_character.GetMaxHealth() * num);
				if (num2)
				{
					_character.SetHealth(_character.GetMaxHealth());
					zDO.Set("DE_BountyInit", true);
				}
				else
				{
					_character.SetHealth(Mathf.Min(health, _character.GetMaxHealth()));
				}
			}
		}

		private void ApplyAggression()
		{
			if (!((Object)(object)_ai == (Object)null))
			{
				((BaseAI)_ai).m_aggravatable = true;
				if (!((BaseAI)_ai).IsAggravated())
				{
					((BaseAI)_ai).SetAggravated(true, (AggravatedReason)0);
				}
				((BaseAI)_ai).SetHuntPlayer(true);
				float num = Mathf.Max(1f, Plugin.BountyAlertRangeMultiplier?.Value ?? 2f);
				if (_baseAlertRange <= 0f)
				{
					_baseAlertRange = _ai.m_alertRange;
				}
				_ai.m_alertRange = _baseAlertRange * num;
				float num2 = Mathf.Max(1f, Plugin.BountyRoamRadius?.Value ?? 12f);
				if (((BaseAI)_ai).m_randomMoveRange > num2)
				{
					((BaseAI)_ai).m_randomMoveRange = num2;
				}
			}
		}

		private void StandDown()
		{
			_standDown = true;
			((Behaviour)this).enabled = false;
		}

		public static bool IsBounty(Character c)
		{
			if ((Object)(object)c != (Object)null)
			{
				return (Object)(object)((Component)c).GetComponent<BountyTarget>() != (Object)null;
			}
			return false;
		}

		public static string BountyIdOf(Character c)
		{
			ZNetView val = (((Object)(object)c != (Object)null) ? ((Component)c).GetComponent<ZNetView>() : null);
			if ((Object)(object)val == (Object)null || !val.IsValid())
			{
				return null;
			}
			return val.GetZDO().GetString("DE_BountyId", (string)null);
		}

		public static void Stamp(GameObject go, string bountyId, int tier, bool minion)
		{
			ZNetView val = (((Object)(object)go != (Object)null) ? go.GetComponent<ZNetView>() : null);
			if (!((Object)(object)val == (Object)null) && val.IsValid())
			{
				ZDO zDO = val.GetZDO();
				zDO.Set("DE_BountyId", bountyId ?? string.Empty);
				zDO.Set("DE_BountyTier", tier);
				zDO.Set("DE_BountyMinion", minion);
			}
		}
	}
	public static class BountyTiers
	{
		public const int MinTier = 1;

		public const int MaxTier = 5;

		public const int EliteTier = 5;

		private static readonly string[] TierNames = new string[5] { "Wanted", "Notorious", "Feared", "Dread", "Accursed" };

		public static string TierName(int tier)
		{
			return TierNames[Mathf.Clamp(tier, 1, 5) - 1];
		}

		public static int Clamp(int tier)
		{
			return Mathf.Clamp(tier, 1, 5);
		}

		public static int BaseTierFor(Biome biome)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Invalid comparison between Unknown and I4
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Invalid comparison between Unknown and I4
			if ((int)biome <= 4)
			{
				if ((int)biome == 2)
				{
					return Plugin.BountyTierSwamp?.Value ?? 2;
				}
				if ((int)biome == 4)
				{
					return Plugin.BountyTierMountain?.Value ?? 3;
				}
			}
			else
			{
				if ((int)biome == 8)
				{
					return Plugin.BountyTierBlackForest?.Value ?? 1;
				}
				if ((int)biome == 16)
				{
					return Plugin.BountyTierPlains?.Value ?? 4;
				}
			}
			return 1;
		}

		public static float HealthMultiplier(int tier)
		{
			float num = Plugin.BountyHealthBase?.Value ?? 3f;
			float num2 = Plugin.BountyHealthGrowth?.Value ?? 1.6f;
			return num * Mathf.Pow(num2, (float)(Clamp(tier) - 1));
		}

		public static int StarLevel(int tier)
		{
			int num = Mathf.Max(1, Plugin.BountyMaxStarLevel?.Value ?? 3);
			float num2 = (float)(Clamp(tier) - 1) / 4f;
			return Mathf.Clamp(Mathf.FloorToInt(1f + num2 * (float)(num - 1) + 0.5f), 1, num);
		}

		public static int MinionCount(int tier)
		{
			int num = Plugin.BountyMinionsBase?.Value ?? 1;
			int num2 = Plugin.BountyMinionsPerTier?.Value ?? 1;
			int num3 = Plugin.BountyMaxMinions?.Value ?? 6;
			return Mathf.Clamp(num + (Clamp(tier) - 1) * num2, 0, Mathf.Max(0, num3));
		}

		public static int MinionTier(int tier)
		{
			return Mathf.Max(1, Clamp(tier) - 1);
		}

		public static string Describe(int tier)
		{
			return $"tier {Clamp(tier)} ({TierName(tier)}): " + $"{HealthMultiplier(tier):F1}x health, {StarLevel(tier)} star(s), {MinionCount(tier)} minion(s)";
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}