using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BTD_Mod_Helper;
using BTD_Mod_Helper.Api;
using BTD_Mod_Helper.Api.Components;
using BTD_Mod_Helper.Api.Display;
using BTD_Mod_Helper.Api.Helpers;
using BTD_Mod_Helper.Api.Towers;
using BTD_Mod_Helper.Api.UI;
using BTD_Mod_Helper.Extensions;
using ChaosMonkey.Btd6;
using ChaosMonkey.Core;
using Il2Cpp;
using Il2CppAssets.Scripts.Models;
using Il2CppAssets.Scripts.Models.Entities;
using Il2CppAssets.Scripts.Models.GenericBehaviors;
using Il2CppAssets.Scripts.Models.TowerSets;
using Il2CppAssets.Scripts.Models.Towers;
using Il2CppAssets.Scripts.Models.Towers.Behaviors;
using Il2CppAssets.Scripts.Models.Towers.Behaviors.Attack;
using Il2CppAssets.Scripts.Models.Towers.Filters;
using Il2CppAssets.Scripts.Models.Towers.Projectiles;
using Il2CppAssets.Scripts.Models.Towers.Projectiles.Behaviors;
using Il2CppAssets.Scripts.Models.Towers.Weapons;
using Il2CppAssets.Scripts.Simulation.Display;
using Il2CppAssets.Scripts.Simulation.Objects;
using Il2CppAssets.Scripts.Simulation.Towers;
using Il2CppAssets.Scripts.Unity.Display;
using Il2CppAssets.Scripts.Unity.UI_New.InGame;
using Il2CppAssets.Scripts.Unity.UI_New.InGame.TowerSelectionMenu;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppTMPro;
using MelonLoader;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: MelonInfo(typeof(ChaosMonkeyMod), "Chaos Monkey", "1.0.0", "Lauri", null)]
[assembly: MelonGame("Ninja Kiwi", "BloonsTD6")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("ChaosMonkey")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("ChaosMonkey")]
[assembly: AssemblyTitle("ChaosMonkey")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ChaosMonkey.Btd6
{
	public sealed class ChaosDeveloperWindow : ModWindow
	{
		private const int ItemsPerPage = 10;

		private const string PanelTexture = "ChaosGachaVerticalPanel";

		private const string TextFieldTexture = "ChaosTextField";

		private readonly Dictionary<EquipmentSlot, ModHelperText> slotTexts = new Dictionary<EquipmentSlot, ModHelperText>();

		private readonly List<ModHelperText> itemTexts = new List<ModHelperText>();

		private EquipmentSlot selectedSlot;

		private int itemPage;

		private ModHelperText? selectedSlotText;

		private ModHelperText? statusText;

		private ModHelperText? pageText;

		private string status = "WÄHLE EINEN SLOT UND DANACH EIN TEST-ITEM.";

		public override int DefaultWidth => 1280;

		public override int DefaultHeight => 1440;

		public override bool AllowMultiple => false;

		public override bool AllowResizing => false;

		public override Info WindowInfo
		{
			get
			{
				//IL_0035: 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_0061: Unknown result type (might be due to invalid IL or missing references)
				Info result = default(Info);
				((Info)(ref result))..ctor(((ModContent)this).Name);
				((Info)(ref result)).set_Width((float)((ModWindow)this).DefaultWidth);
				((Info)(ref result)).set_Height((float)((ModWindow)this).DefaultHeight);
				((Info)(ref result)).set_Anchor(new Vector2(0.5f, 0.5f));
				((Info)(ref result)).set_Pivot(new Vector2(0.5f, 0.5f));
				((Info)(ref result)).set_Position(Vector2.zero);
				return result;
			}
		}

		public override void ModifyWindow(ModHelperWindow window)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: 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)
			((ModHelperComponent)window.content).AddImage(new Info("DeveloperPanel", 0f, 0f, 1150f, 1320f), ModContent.GetSpriteReference<ChaosMonkeyMod>("ChaosGachaVerticalPanel").guidRef);
			AddTextField(window, "DeveloperHeader", 0f, 572f, 880f, 68f, "CHAOS MONKEY • DEVELOPER LOADOUT", 31f);
			AddTextField(window, "DeveloperWarning", 0f, 497f, 880f, 52f, "TEST-MODUS • KEINE ROLLS, PITYS ODER ACHIEVEMENTS", 22f);
			selectedSlotText = AddTextField(window, "DeveloperSelectedSlot", 195f, 414f, 600f, 50f, BuildSelectedSlotText(), 23f);
			float num = 352f;
			EquipmentSlot[] values = Enum.GetValues<EquipmentSlot>();
			foreach (EquipmentSlot slot in values)
			{
				AddSlotButton(window, slot, num);
				num -= 114f;
			}
			for (int j = 0; j < 10; j++)
			{
				AddItemButton(window, j, 352f - (float)j * 84f);
			}
			AddPageButton(window, "DeveloperPreviousPage", -90f, -475f, "PREVIOUS PAGE", delegate
			{
				ChangePage(-1);
			});
			pageText = AddTextField(window, "DeveloperPage", 245f, -475f, 300f, 46f, BuildPageText(), 19f);
			AddPageButton(window, "DeveloperNextPage", 580f, -475f, "NEXT PAGE", delegate
			{
				ChangePage(1);
			});
			statusText = AddTextField(window, "DeveloperStatus", 0f, -540f, 930f, 62f, status, 20f);
			((Graphic)GameObjectExt.AddButton(((Component)window.content).gameObject, new Info("DeveloperClose", 0f, -612f, 560f, 62f), "F8 • SCHLIESSEN", (Action)delegate
			{
				window.Close();
			}).Image).color = new Color(1f, 1f, 1f, 0f);
		}

		public override void OnUpdate(ModHelperWindow window)
		{
			if (!ChaosMonkeyMod.IsDeveloperModeAvailable || !ChaosMonkeyMod.Session.IsChaosMonkeyPresent)
			{
				window.Close();
				return;
			}
			ModHelperText? obj = selectedSlotText;
			if (obj != null)
			{
				obj.SetText(BuildSelectedSlotText());
			}
			ModHelperText? obj2 = statusText;
			if (obj2 != null)
			{
				obj2.SetText(status);
			}
			ModHelperText? obj3 = pageText;
			if (obj3 != null)
			{
				obj3.SetText(BuildPageText());
			}
			if (Input.GetKeyDown((KeyCode)280) || Input.GetKeyDown((KeyCode)276))
			{
				ChangePage(-1);
			}
			if (Input.GetKeyDown((KeyCode)281) || Input.GetKeyDown((KeyCode)275))
			{
				ChangePage(1);
			}
			foreach (var (slot, val2) in slotTexts)
			{
				val2.SetText(BuildSlotText(slot));
			}
			IReadOnlyList<ItemDefinition> developerItems = ChaosMonkeyMod.Session.GetDeveloperItems(selectedSlot);
			int num = itemPage * 10;
			for (int i = 0; i < itemTexts.Count; i++)
			{
				int num2 = num + i;
				itemTexts[i].SetText((num2 < developerItems.Count) ? BuildItemText(developerItems[num2]) : string.Empty);
			}
		}

		public override void OnClose(ModHelperWindow window)
		{
			slotTexts.Clear();
			itemTexts.Clear();
			selectedSlotText = null;
			statusText = null;
			pageText = null;
			itemPage = 0;
		}

		private void AddSlotButton(ModHelperWindow window, EquipmentSlot slot, float y)
		{
			//IL_00bb: 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)
			slotTexts[slot] = AddTextField(window, $"DeveloperSlot{slot}", -302f, y, 390f, 88f, BuildSlotText(slot), 22f);
			((Graphic)GameObjectExt.AddButton(((Component)window.content).gameObject, new Info($"DeveloperSlotSelect{slot}", -302f, y, 408f, 94f), string.Empty, (Action)delegate
			{
				selectedSlot = slot;
				itemPage = 0;
				status = GetSlotName(slot) + " AUSGEWÄHLT • RECHTS EIN ITEM ANKLICKEN.";
			}).Image).color = new Color(1f, 1f, 1f, 0f);
		}

		private void AddItemButton(ModHelperWindow window, int index, float y)
		{
			//IL_00b0: 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)
			ModHelperText item = AddTextField(window, $"DeveloperItem{index}", 245f, y, 650f, 70f, string.Empty, 22f);
			itemTexts.Add(item);
			((Graphic)GameObjectExt.AddButton(((Component)window.content).gameObject, new Info($"DeveloperItemSelect{index}", 245f, y, 674f, 76f), string.Empty, (Action)delegate
			{
				ApplyItem(index);
			}).Image).color = new Color(1f, 1f, 1f, 0f);
		}

		private static void AddPageButton(ModHelperWindow window, string name, float x, float y, string label, Action action)
		{
			//IL_003d: 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)
			AddTextField(window, name + "Label", x, y, 200f, 46f, label, 17f);
			((Graphic)GameObjectExt.AddButton(((Component)window.content).gameObject, new Info(name, x, y, 206f, 52f), string.Empty, action).Image).color = new Color(1f, 1f, 1f, 0f);
		}

		private void ApplyItem(int index)
		{
			IReadOnlyList<ItemDefinition> developerItems = ChaosMonkeyMod.Session.GetDeveloperItems(selectedSlot);
			int num = itemPage * 10 + index;
			if (num >= developerItems.Count)
			{
				return;
			}
			try
			{
				ItemDefinition itemDefinition = developerItems[num];
				ChaosMonkeyMod.EquipDeveloperItem(itemDefinition.Id);
				status = "TEST-ITEM GESETZT: " + itemDefinition.DisplayName.ToUpperInvariant() + " • KEINE ACHIEVEMENTS.";
			}
			catch (InvalidOperationException ex)
			{
				status = ex.Message.ToUpperInvariant();
			}
		}

		private void ChangePage(int direction)
		{
			int pageCount = GetPageCount();
			itemPage = Mathf.Clamp(itemPage + direction, 0, pageCount - 1);
		}

		private int GetPageCount()
		{
			int count = ChaosMonkeyMod.Session.GetDeveloperItems(selectedSlot).Count;
			return Math.Max(1, (count + 10 - 1) / 10);
		}

		private string BuildPageText()
		{
			return $"SEITE {itemPage + 1} / {GetPageCount()}";
		}

		private string BuildSelectedSlotText()
		{
			EvolutionState evolutionState = ChaosMonkeyMod.Session.Match?.Evolution;
			string text = ((evolutionState != null && evolutionState.IsInProgress) ? "EVOLUTION LÄUFT • SLOTS GESPERRT" : ((evolutionState != null && evolutionState.IsComplete) ? "EVOLUTION ABGESCHLOSSEN • SLOTS GESPERRT" : "TEST-AUSRÜSTUNG"));
			return "AUSGEWÄHLT: " + GetSlotName(selectedSlot) + " • " + text;
		}

		private string BuildSlotText(EquipmentSlot slot)
		{
			ItemDefinition itemDefinition = ChaosMonkeyMod.Session.Match?.GetItem(slot);
			string text = ((slot == selectedSlot) ? "  •  AUSGEWÄHLT" : string.Empty);
			return GetSlotName(slot) + text + "\n" + (((object)itemDefinition == null) ? "LEER" : itemDefinition.DisplayName.ToUpperInvariant());
		}

		private static string BuildItemText(ItemDefinition item)
		{
			return $"{item.Rarity.ToString().ToUpperInvariant()}  •  {item.DisplayName.ToUpperInvariant()}\n{item.Summary.ToUpperInvariant()}";
		}

		private static ModHelperText AddTextField(ModHelperWindow window, string name, float x, float y, float width, float height, string text, float fontSize)
		{
			//IL_0017: 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)
			((ModHelperComponent)window.content).AddImage(new Info(name + "Panel", x, y, width, height), ModContent.GetSpriteReference<ChaosMonkeyMod>("ChaosTextField").guidRef);
			ModHelperText obj = ((ModHelperComponent)window.content).AddText(new Info(name, x, y, width - 28f, height - 8f), text, fontSize, (TextAlignmentOptions)514);
			obj.EnableAutoSizing(fontSize, 16f);
			return obj;
		}

		private static string GetSlotName(EquipmentSlot slot)
		{
			return slot switch
			{
				EquipmentSlot.Weapon => "WAFFE", 
				EquipmentSlot.Ammo => "MUNITION", 
				EquipmentSlot.Body => "KÖRPER", 
				EquipmentSlot.Head => "KOPF", 
				EquipmentSlot.Trait => "TRAIT", 
				EquipmentSlot.Ability => "FÄHIGKEIT", 
				_ => slot.ToString().ToUpperInvariant(), 
			};
		}
	}
	public sealed class ChaosMonkeyGodlyEvolutionDisplay : ModTowerCustomDisplay<ChaosMonkeyTower>
	{
		public override string AssetBundleName => "chaosmonkeyevolutions";

		public override string PrefabName => "ChaosMonkeyGodlyEvolution";

		public override bool LoadAsync => false;

		public override bool UseForTower(params int[] tiers)
		{
			return false;
		}

		public override void ModifyDisplayNode(UnityDisplayNode node)
		{
			ChaosEvolutionDisplayMaterials.Apply(node, secret: false);
		}
	}
	public sealed class ChaosMonkeySecretEvolutionDisplay : ModTowerCustomDisplay<ChaosMonkeyTower>
	{
		public override string AssetBundleName => "chaosmonkeyevolutions";

		public override string PrefabName => "ChaosMonkeySecretEvolution";

		public override bool LoadAsync => false;

		public override bool UseForTower(params int[] tiers)
		{
			return false;
		}

		public override void ModifyDisplayNode(UnityDisplayNode node)
		{
			ChaosEvolutionDisplayMaterials.Apply(node, secret: true);
		}
	}
	internal static class ChaosEvolutionDisplayMaterials
	{
		private static Material? safeTowerMaterial;

		internal static void CaptureTowerMaterial(UnityDisplayNode? node)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			if ((Object)(object)safeTowerMaterial != (Object)null || (Object)(object)node == (Object)null)
			{
				return;
			}
			foreach (Renderer componentsInChild in ((Component)node).GetComponentsInChildren<Renderer>(true))
			{
				if (!((Object)(object)componentsInChild.sharedMaterial == (Object)null))
				{
					safeTowerMaterial = new Material(componentsInChild.sharedMaterial);
					break;
				}
			}
		}

		internal static void Apply(UnityDisplayNode node, bool secret)
		{
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: 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_00e1: 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_0104: Unknown result type (might be due to invalid IL or missing references)
			Sprite sprite = ModContent.GetSprite<ChaosMonkeyMod>(secret ? "ChaosMonkeySecretEvolution" : "ChaosMonkeyGodlyEvolution", 100f);
			Texture2D val = ((sprite == null) ? null : sprite.texture);
			foreach (Renderer componentsInChild in ((Component)node).GetComponentsInChildren<Renderer>(true))
			{
				bool flag = ((Object)((Component)componentsInChild).gameObject).name.StartsWith("SolidMonkey_", StringComparison.Ordinal);
				Material val2 = CreateSafeMaterial(flag ? null : val);
				if (!((Object)(object)val2 == (Object)null))
				{
					if (val2.HasProperty("_Cull"))
					{
						val2.SetInt("_Cull", 0);
					}
					Color val3 = ((!flag && val != null) ? Color.white : GetPartColor(((Object)((Component)componentsInChild).gameObject).name, secret));
					if (val2.HasProperty("_Color"))
					{
						val2.SetColor("_Color", val3);
					}
					if (val2.HasProperty("_BaseColor"))
					{
						val2.SetColor("_BaseColor", val3);
					}
					if (val2.HasProperty("_EmissionColor"))
					{
						val2.SetColor("_EmissionColor", val3 * 0.2f);
					}
					componentsInChild.material = val2;
					componentsInChild.enabled = true;
				}
			}
		}

		private static Material? CreateSafeMaterial(Texture2D? conceptTexture)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Expected O, but got Unknown
			Shader val = Shader.Find("Sprites/Default");
			if ((Object)(object)val != (Object)null)
			{
				Material val2 = new Material(val);
				if (val2.HasProperty("_MainTex"))
				{
					val2.SetTexture("_MainTex", (Texture)(object)(conceptTexture ?? Texture2D.whiteTexture));
				}
				return val2;
			}
			if ((Object)(object)safeTowerMaterial != (Object)null)
			{
				return new Material(safeTowerMaterial);
			}
			Shader val3 = Shader.Find("Unlit/Color");
			if (!((Object)(object)val3 == (Object)null))
			{
				return new Material(val3);
			}
			return null;
		}

		private static Color GetPartColor(string name, bool secret)
		{
			//IL_0072: 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_00dd: 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)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: 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_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			int num = name.LastIndexOf("__CM", StringComparison.Ordinal);
			if (num >= 0 && name.Length >= num + "__CM".Length + 8)
			{
				string text = name.Substring(num + "__CM".Length, 8);
				Color result = default(Color);
				if (ColorUtility.TryParseHtmlString("#" + text, ref result))
				{
					return result;
				}
			}
			if (name.Contains("Eye"))
			{
				return new Color(0.1f, 0.94f, 1f, 1f);
			}
			if (name.Contains("Crystal") || name.Contains("Core") || name.Contains("Gem") || name.Contains("Planet"))
			{
				if (!secret)
				{
					return new Color(0.95f, 0.18f, 1f, 1f);
				}
				return new Color(0.86f, 0.07f, 1f, 1f);
			}
			if (name.Contains("Crown") || name.Contains("Halo") || name.Contains("Staff"))
			{
				if (!secret)
				{
					return new Color(1f, 0.72f, 0.1f, 1f);
				}
				return new Color(0.22f, 0.04f, 0.48f, 1f);
			}
			if (name.Contains("Robe") || name.Contains("Cape") || name.Contains("Hood"))
			{
				if (!secret)
				{
					return new Color(0.31f, 0.06f, 0.62f, 1f);
				}
				return new Color(0.035f, 0.008f, 0.1f, 1f);
			}
			if (!secret)
			{
				return new Color(0.47f, 0.2f, 0.09f, 1f);
			}
			return new Color(0.055f, 0.012f, 0.14f, 1f);
		}
	}
	internal static class ChaosItemArtwork
	{
		private static readonly Dictionary<string, Sprite> sprites = new Dictionary<string, Sprite>(StringComparer.Ordinal);

		internal static Sprite GetSprite(ItemDefinition item)
		{
			if (sprites.TryGetValue(item.Id, out Sprite value))
			{
				return value;
			}
			Sprite sprite = ModContent.GetSprite<ChaosMonkeyMod>($"ChaosItemIcon{item.Slot}{item.Rarity}", 100f);
			sprites[item.Id] = sprite;
			return sprite;
		}

		internal static Color GetTint(ItemDefinition item)
		{
			//IL_0026: 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_007e: 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_00e8: 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_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			if (item.Tags.Contains("Fire"))
			{
				return new Color(1f, 0.58f, 0.38f, 1f);
			}
			if (item.Tags.Contains("Frost"))
			{
				return new Color(0.48f, 0.88f, 1f, 1f);
			}
			if (item.Tags.Contains("Poison"))
			{
				return new Color(0.55f, 1f, 0.42f, 1f);
			}
			if (item.Tags.Contains("Lightning"))
			{
				return new Color(0.72f, 0.86f, 1f, 1f);
			}
			if (item.Tags.Contains("Gravity") || item.Tags.Contains("Void"))
			{
				return new Color(0.72f, 0.45f, 1f, 1f);
			}
			if (item.Tags.Contains("Time"))
			{
				return new Color(1f, 0.78f, 0.35f, 1f);
			}
			if (item.Tags.Contains("Reality"))
			{
				return new Color(1f, 0.42f, 0.78f, 1f);
			}
			if (item.Rarity == Rarity.Secret)
			{
				return new Color(0.72f, 0.42f, 1f, 1f);
			}
			return Color.white;
		}
	}
	internal sealed record ChaosItemDetails(string Stats, string Effect, string Synergy);
	internal static class ChaosItemDetailsCatalog
	{
		public static ChaosItemDetails Get(ItemDefinition item)
		{
			return item.Id switch
			{
				"rusty-dart" => Detail("1 DMG • 3 PIERCE • 0.90s", "Simple rapid dart attack. A dependable opening weapon.", "Pairs with basic or burning ammunition."), 
				"chaos-slingshot" => Detail("2 DMG • 2 PIERCE • 1.00s", "Launches heavy chaotic pebbles for reliable early damage.", "Chaos Ammo effects can add splinters."), 
				"twin-darts" => Detail("2 DARTS • 1 DMG • 0.95s", "Fires a matched pair of darts with each attack.", "Benefits especially from split and burning ammunition."), 
				"scrap-blaster" => Detail("1 DMG • 6 PIERCE • 1.10s", "Sprays a broad piece of scrap through grouped Bloons.", "Pierce bonuses turn scrap into crowd control."), 
				"chaos-needle" => Detail("1 DMG • 2 PIERCE • 0.35s", "Fires extremely quickly at a single target.", "Proc ammunition has many chances to trigger."), 
				"pebble-launcher" => Detail("3 DMG • 2 PIERCE • 1.45s", "Throws slow, heavy pebbles with strong direct impact.", "Gravity effects keep targets in the impact line."), 
				"broken-wand" => Detail("1 DMG • BONUS HIT 15%", "A cracked wand occasionally fires an additional magic bolt.", "Luck improves the bonus-hit chance."), 
				"toy-cannon" => Detail("4 DMG • 3 PIERCE • 1.70s", "A deceptively strong toy shell fires very slowly.", "Explosion ammunition increases its impact area."), 
				"double-chaos-blaster" => Detail("2 BOLTS • 2 DMG • 0.80s", "Releases two chaotic bolts at once.", "Chaos Affinity strengthens both bolts."), 
				"spiked-launcher" => Detail("4 DMG • 8 PIERCE • 1.10s", "Fires a heavy spike that tears through dense groups.", "Piercing Plasma pushes the pierce even higher."), 
				"mini-cannon" => Detail("3 DMG • SMALL BLAST • 1.25s", "Fires compact shells that damage nearby Bloons on impact.", "Gravity Ammo clusters targets for the blast."), 
				"ricochet-gun" => Detail("2 DMG • 4 PIERCE • 1 BOUNCE", "Every shot rebounds once into a nearby Bloon.", "Extra bounces with Lightning Ammo."), 
				"poison-dart-gun" => Detail("1 DMG • POISON 4s • 0.70s", "Poisons hit Bloons, dealing damage over time.", "Toxic effects combine with Poison Ammo."), 
				"rapid-chaos-bow" => Detail("2 DMG • 3 PIERCE • 0.45s", "Rapidly fires chaotic arrows down the track.", "Chaos Split Ammo creates a fragment storm."), 
				"plasma-rifle" => Detail("3 DMG • 10 PIERCE • 0.65s", "Fires hot plasma rounds that cut through crowds.", "Plasma shots benefit strongly from Body bonuses."), 
				"gravity-cannon" => Detail("3 DMG • PULL • 1.15s", "Impacts create a small gravity pull around the target.", "Gravity Ammo extends the pull duration."), 
				"chain-lightning-staff" => Detail("2 DMG • 4 TARGETS • 0.80s", "A lightning strike jumps between nearby targets.", "Storm equipment adds chain targets."), 
				"frost-launcher" => Detail("2 DMG • CHILL 30% • 1.05s", "Chilling shells slow struck Bloons for a short time.", "Freezing effects strengthen the chill."), 
				"meteor-cannon" => Detail("5 DMG • METEOR 12% • 1.30s", "Occasionally calls a meteor onto the current target area.", "Meteor Ammo raises the impact frequency."), 
				"void-blaster" => Detail("4 DMG • 12 PIERCE • 0.75s", "Void bolts pierce dense groups and leave a brief tear.", "Void Mask and Void Ammo amplify rifts."), 
				"soul-reaper" => Detail("3 DMG • EXECUTE BONUS • 0.85s", "Deals increasing bonus damage to already weakened Bloons.", "Soul effects mark targets for the Reaper."), 
				"black-hole-launcher" => Detail("5 DMG • 6 PIERCE • 1.20s", "Impacts briefly pull Bloons toward a miniature singularity.", "Gravity equipment extends the pull."), 
				"chaos-accelerator" => Detail("2–8 DMG • COMBO • 0.55s", "Repeated hits on the same target grow stronger until the combo breaks.", "Focused keeps the combo on tough targets."), 
				"reality-rifle" => Detail("7 DMG • 18 PIERCE • 0.90s", "Some shots bypass ordinary Bloon physics and properties.", "Reality Ammo makes bypasses more reliable."), 
				"dragon-cannon" => Detail("8 DMG/s • BEAM • 18 PIERCE", "Channels a continuous dragonfire beam through Bloons.", "Dragonfire Ammo adds a spreading flame wave."), 
				"time-breaker" => Detail("6 DMG • TIME SLOW 20% • 1.00s", "Hits sometimes briefly slow the target; the effect is weaker against MOABs.", "Time Ammo and Time Crown extend the slow."), 
				"void-destroyer" => Detail("14 DMG • RIFT • 1.40s", "Each impact opens a damaging void rift on the track.", "Rift Ammo makes each rift wider."), 
				"judgement-cannon" => Detail("12 DMG • +MOAB DMG • 1.90s", "Fires an immense slow shell that deals more damage to powerful targets.", "Focused and World Eater raise its MOAB damage."), 
				"eternal-chaos" => Detail("CHAOS PROC • 0.55s", "Each attack randomly triggers lightning, gravity, fire, time or void.", "Full Godly Harmony stabilizes every chaos proc."), 
				"genesis-weapon" => Detail("ADAPTIVE ATTACK • 0.60s", "Changes its projectile form to match the equipped Ammo and build.", "Its strongest form is discovered through mixed-element loadouts."), 
				"basic-ammo" => Detail("STANDARD ROUND", "Reliable ammunition with no additional effect.", "A clean base for any weapon."), 
				"burning-ammo" => Detail("+1 BURN DMG • 3s", "Hits ignite Bloons and deal damage over time.", "Dragon Cannon turns burns into wider flames."), 
				"lightning-ammo" => Detail("+2 CHAIN TARGETS", "A hit releases a short chain of lightning.", "Storm Helmet and Staff increase the chain."), 
				"gravity-ammo" => Detail("PULL • 1.0s", "Hits drag nearby Bloons toward the impact point.", "Black Hole Launcher strengthens the pull."), 
				"void-ammo" => Detail("VOID TEAR • 12%", "Some impacts leave a brief damaging void tear.", "Void Blaster improves tear duration."), 
				"chaos-split-ammo" => Detail("3 SPLINTERS • 25%", "A quarter of hits split into three chaotic fragments.", "Chaos Affinity increases split reliability."), 
				"dragonfire-ammo" => Detail("FIRE WAVE • 4s", "Direct hits emit a short dragonfire wave.", "Dragon Cannon doubles the visual fire trail."), 
				"rift-ammo" => Detail("AREA RIFT • 2.5s", "Creates a larger area-damage rift after impact.", "Void and Reality loadouts expand the rift."), 
				"law-of-chaos-ammo" => Detail("ADAPTIVE PROC • EVERY HIT", "Adapts a random elemental effect to the equipped weapon.", "Full Godly Harmony lets all elements coexist."), 
				"basic-body" => Detail("+1 DMG • +1 PIERCE", "A small all-round improvement to the Monkey's attacks.", "Useful with every early loadout."), 
				"storm-body" => Detail("STORM PULSE • 5s", "Periodically releases a lightning pulse around the Monkey.", "Storm Helmet gives the pulse more targets."), 
				"gravity-body" => Detail("PULL AURA • 12 RANGE", "A small field slows and draws nearby Bloons together.", "Gravity Ammo makes the aura more forceful."), 
				"chaos-core-body" => Detail("ROTATING BONUS • 4s", "Cycles through small damage, pierce, speed and range bonuses.", "Chaos weapons inherit the active bonus."), 
				"time-lord-body" => Detail("TIME SLOW • 15%", "Nearby Bloons are periodically slowed by warped time.", "Time Crown extends the slow duration."), 
				"world-eater-body" => Detail("+MOAB DMG • STACKING", "Gains additional power while fighting MOAB-class Bloons.", "Focused makes every MOAB stack stronger."), 
				"celestial-core" => Detail("5-SLOT AMPLIFIER", "Empowers the other five equipped slots at once.", "A key component of Godly Harmony."), 
				"singularity-body" => Detail("BLACK HOLE • 18s", "Occasionally forms a compact black hole that pulls and damages Bloons.", "Secret Harmony turns it into a galaxy rift."), 
				"basic-cap" => Detail("FOCUS TARGETING", "Improves target focus for consistent first-target attacks.", "Works with every weapon."), 
				"storm-helmet" => Detail("+2 STORM TARGETS", "Storm and lightning effects can hit more targets.", "Best with Lightning Ammo or the Staff."), 
				"void-mask" => Detail("+20% VOID DURATION", "Void tears and rifts remain active longer.", "Pairs with Void Blaster and Rift Ammo."), 
				"reality-mask" => Detail("PROPERTY BYPASS • 20%", "Some attacks partially ignore Bloon properties.", "Reality Collapse gains extra area damage."), 
				"time-crown" => Detail("+30% TIME EFFECT", "Extends and strengthens all time manipulation.", "Time Stop becomes more reliable."), 
				"crown-of-oblivion" => Detail("OBLIVION MARK • 10%", "Marked Bloons receive amplified void and reality damage.", "Void Destroyer consumes the mark."), 
				"crown-of-infinity" => Detail("GODLY AMPLIFIER", "Raises the effect of every Godly item in the loadout.", "Required for a fully harmonized Godly build."), 
				"quick-learner" => Detail("+12% ATTACK SPEED", "The Monkey attacks faster with every weapon.", "A flexible early-game trait."), 
				"lucky" => Detail("+8% PROC CHANCE", "Slightly improves every chance-based effect.", "Helps chaos, void and critical effects."), 
				"focused" => Detail("+25% MOAB DMG", "Deals more damage to MOAB-class Bloons.", "Excellent with World Eater Body."), 
				"gambler" => Detail("CRIT • 8% ×5", "Rare hits deal massively increased damage.", "Absolute Luck increases crit consistency."), 
				"chaos-affinity" => Detail("+25% CHAOS POWER", "Strengthens random chaos effects and their duration.", "Eternal Chaos becomes much more stable."), 
				"reality-bender" => Detail("RULE SHIFT • 12s", "Periodically changes one active combat rule in your favor.", "Reality Mask reveals the next shift."), 
				"absolute-luck" => Detail("+35% PROC POWER", "Strongly boosts all chance-based effects and random outcomes.", "Godly Harmony shares the luck bonus."), 
				"chaos-blast" => Detail("ABILITY • 20s CD", "Detonates a small chaos blast at the selected location.", "Chaos Affinity adds a random secondary effect."), 
				"lightning-strike" => Detail("ABILITY • 24s CD", "Calls a targeted lightning strike onto the track.", "Storm equipment causes additional jumps."), 
				"gravity-pulse" => Detail("ABILITY • 28s CD", "Pulls nearby Bloons into a compact cluster.", "Gravity Body increases the pulse radius."), 
				"void-rift" => Detail("ABILITY • 34s CD", "Creates a large damaging rift on the track.", "Void Mask extends the rift duration."), 
				"time-stop" => Detail("ABILITY • 42s CD", "Temporarily slows the entire nearby track.", "Time Lord Body increases slow strength."), 
				"reality-collapse" => Detail("ABILITY • 50s CD", "Collapses reality in an area and deals damage over time.", "Reality Mask allows partial property bypass."), 
				"ascendant-chaos" => Detail("ABILITY • 60s CD", "Triggers a coordinated surge of all six Godly effects.", "Full Godly Harmony lowers its cooldown."), 
				"the-unwritten-blade" => Detail("UNWRITTEN RULE • PROPERTY ERASE", "A black blade can remove Camo, Regrow or Fortified from the target.", "Pairs with Reality effects; all six Secrets begin Unknown Resonance."), 
				"event-horizon" => Detail("COLLAPSE • SCALING SINGULARITY", "Creates a singularity at the target; stronger Bloons make stronger collapses.", "Combines with Singularity Core and The Black Halo."), 
				"null-weapon" => Detail("[NULL] • NO VISIBLE SHOT", "It seems to fire nothing until Bloons vanish outside normal damage rules.", "Its hidden interaction is revealed only by other Secret items."), 
				"forbidden-matter" => Detail("CORRUPTION • DETONATION", "Hits add corruption; a fully corrupted Bloon explodes.", "Works especially well with rapid or split weapons."), 
				"yesterday" => Detail("TIME ECHO • REWIND HIT", "A struck Bloon can be returned to an earlier point on the track.", "Pairs with Rewind for the Paradox Secret synergy."), 
				"outside" => Detail("OUTSIDE MAP • PHASE SHOT", "Shots pass obstacles, bypass protected targets and can reappear behind them.", "Reality and Null effects unlock its strangest behaviour."), 
				"observer-body" => Detail("OBSERVATION • ESCALATING MARK", "Bloons remaining in view are marked and take increasingly heavy damage.", "Pairs with The Watching Eye to form The Observer."), 
				"singularity-core" => Detail("GRAVITY • CROWD POWER", "Pulls nearby Bloons inward and becomes stronger as the crowd grows.", "Pairs with The Black Halo for Endless Gravity."), 
				"forgotten-body" => Detail("FORGOTTEN • RECOGNITION LOSS", "Some Bloons lose their normal recognition of the Monkey.", "A Secret-only defensive rule break."), 
				"watching-eye" => Detail("PREDICTION • PERFECT TRACKING", "Predicts movement for exceptionally precise target acquisition.", "Pairs with Observer Body for The Observer."), 
				"crown-of-nothing" => Detail("NOTHING • RULE REMOVAL", "Every 20–30 seconds removes a negative effect and may erase enemy properties.", "Reality effects make property removal more reliable."), 
				"the-black-halo" => Detail("GRAVITY RING • CHARGED WAVE", "Continuously slows and gathers Bloons before releasing a gravity wave.", "Pairs with Singularity Core for Endless Gravity."), 
				"impossible-luck" => Detail("INVISIBLE LUCK CHECK", "Every roll secretly receives a second luck check.", "A Secret effect: it never appears in the public odds table."), 
				"fate-secret" => Detail("FATE COUNTER • EVENT", "A hidden counter grows while the Monkey survives, then triggers a powerful random event.", "Works with Yesterday for the Paradox route."), 
				"existence" => Detail("EXISTENCE • SIX-SLOT BONUS", "Some normal rules cannot affect the Monkey; all six categories receive a small bonus.", "Enhances every completed Secret loadout."), 
				"erase" => Detail("ERASE • LONG COOLDOWN", "After a delay, destroys normal Bloons or deals huge BAD and boss damage.", "Secret Evolution turns it into an ascendant reality tear."), 
				"rewind" => Detail("REWIND • TIME RESET", "Returns Bloons to earlier positions and repeats part of recent damage.", "Pairs with Yesterday for the Paradox Secret synergy."), 
				"unknown-ability" => Detail("??? • UNPREDICTABLE", "After a silent delay, it chooses a massive random Secret effect.", "The full Secret set reveals the Unknown Resonance."), 
				_ => CreateDefault(item), 
			};
		}

		public static ChaosItemDetails Empty(EquipmentSlot slot)
		{
			return new ChaosItemDetails($"{ChaosEconomy.SlotRollCosts[slot]} SHARDS • SELECTED ROLL", "Choose " + SlotName(slot) + " and use a Normal Roll to discover its first item.", "Items with matching tags unlock synergy bonuses. The final evolutions remain hidden.");
		}

		public static string SlotName(EquipmentSlot slot)
		{
			return slot switch
			{
				EquipmentSlot.Weapon => "WEAPON", 
				EquipmentSlot.Ammo => "AMMO", 
				EquipmentSlot.Body => "BODY", 
				EquipmentSlot.Head => "HEAD", 
				EquipmentSlot.Trait => "TRAIT", 
				EquipmentSlot.Ability => "ABILITY", 
				_ => slot.ToString().ToUpperInvariant(), 
			};
		}

		private static ChaosItemDetails Detail(string stats, string effect, string synergy)
		{
			return new ChaosItemDetails(stats, effect, synergy);
		}

		private static ChaosItemDetails CreateDefault(ItemDefinition item)
		{
			string[] array = item.Tags.Where((string tag) => !string.Equals(tag, "Secret", StringComparison.OrdinalIgnoreCase)).ToArray();
			string text = ((array.Length == 0) ? "GENERAL" : string.Join(" • ", array).ToUpperInvariant());
			return Detail($"{item.Rarity.ToString().ToUpperInvariant()} {SlotName(item.Slot)} • {text}", item.Summary, (array.Length == 0) ? "A flexible item with no required pairing." : ("SYNERGY: combines with matching " + text + " equipment."));
		}
	}
	public sealed class ChaosLuckOddsWindow : ModWindow
	{
		private const float TableScale = 1.35f;

		private const string TextFieldTexture = "ChaosTextField";

		private readonly Dictionary<Rarity, ModHelperText> oddsLabels = new Dictionary<Rarity, ModHelperText>();

		private readonly GachaEngine gacha = new GachaEngine();

		private ModHelperText? luckText;

		private ModHelperText? nextLuckText;

		private ModHelperText? resultText;

		private string result = "NORMAL ROLLS USE THE DISPLAYED ODDS.";

		public override int DefaultWidth => 920;

		public override int DefaultHeight => 480;

		public override bool AllowMultiple => false;

		public override bool AllowResizing => false;

		public override Info WindowInfo
		{
			get
			{
				//IL_0035: 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_0061: 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)
				Info val = default(Info);
				((Info)(ref val))..ctor(((ModContent)this).Name);
				((Info)(ref val)).set_Width((float)((ModWindow)this).DefaultWidth);
				((Info)(ref val)).set_Height((float)((ModWindow)this).DefaultHeight);
				((Info)(ref val)).set_Anchor(new Vector2(0.5f, 1f));
				((Info)(ref val)).set_Pivot(new Vector2(0.5f, 1f));
				((Info)(ref val)).set_Position(new Vector2(-270f, -8f));
				return val;
			}
		}

		public override void ModifyWindow(ModHelperWindow window)
		{
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			AddField(window, "LuckOddsTitle", 0f, 102f, 560f, 42f, "LUCK & DROP ODDS", 24f);
			luckText = AddField(window, "CurrentLuck", -174f, 56f, 210f, 40f, BuildLuckText(), 22f);
			nextLuckText = AddField(window, "NextLuck", 165f, 56f, 290f, 40f, BuildNextLuckText(), 18f);
			((Graphic)GameObjectExt.AddButton(((Component)window.content).gameObject, TableInfo("BuyNextLuck", 165f, 56f, 292f, 42f), string.Empty, (Action)PurchaseNextLuck).Image).color = new Color(1f, 1f, 1f, 0f);
			AddOddsRow(window, Rarity.Common, -172f, 8f);
			AddOddsRow(window, Rarity.Uncommon, -172f, -36f);
			AddOddsRow(window, Rarity.Rare, -172f, -80f);
			AddOddsRow(window, Rarity.Epic, -172f, -124f);
			AddOddsRow(window, Rarity.Legendary, 172f, 8f);
			AddOddsRow(window, Rarity.Mythic, 172f, -36f);
			AddOddsRow(window, Rarity.Godly, 172f, -80f);
			resultText = AddField(window, "LuckOddsResult", 0f, -178f, 670f, 36f, result, 15f);
		}

		public override void OnUpdate(ModHelperWindow window)
		{
			ModHelperText? obj = luckText;
			if (obj != null)
			{
				obj.SetText(BuildLuckText());
			}
			ModHelperText? obj2 = nextLuckText;
			if (obj2 != null)
			{
				obj2.SetText(BuildNextLuckText());
			}
			ModHelperText? obj3 = resultText;
			if (obj3 != null)
			{
				obj3.SetText(result);
			}
			foreach (var (rarity2, val2) in oddsLabels)
			{
				val2.SetText(BuildOddsText(rarity2));
			}
		}

		public override void OnClose(ModHelperWindow window)
		{
			luckText = null;
			nextLuckText = null;
			resultText = null;
			oddsLabels.Clear();
		}

		private void AddOddsRow(ModHelperWindow window, Rarity rarity, float x, float y)
		{
			oddsLabels[rarity] = AddField(window, $"Odds{rarity}", x, y, 305f, 34f, BuildOddsText(rarity), 17f);
		}

		private void PurchaseNextLuck()
		{
			try
			{
				int? nextLuck = GetNextLuck();
				if (!nextLuck.HasValue)
				{
					result = "LUCK IS ALREADY AT THE MAXIMUM ×2048.";
					return;
				}
				ChaosMonkeyMatchState? match = ChaosMonkeyMod.Session.Match;
				InGame instance = InGame.instance;
				if (match == null || !ChaosMonkeyMod.Session.IsChaosMonkeyPresent || instance == null)
				{
					throw new InvalidOperationException("SELECT AN ACTIVE CHAOS MONKEY FIRST.");
				}
				int num = ChaosEconomy.LuckCashCosts[nextLuck.Value];
				if (InGameExt.GetCash(instance) < (double)num)
				{
					result = $"NOT ENOUGH CASH FOR LUCK ×{nextLuck.Value}.";
				}
				else
				{
					InGameExt.AddCash(instance, (double)(-num));
					ChaosMonkeyMod.Session.PurchaseLuck(nextLuck.Value);
					result = $"LUCK UPGRADED TO ×{nextLuck.Value}. DROP ODDS UPDATED.";
				}
			}
			catch (InvalidOperationException ex)
			{
				result = ex.Message.ToUpperInvariant();
			}
		}

		private static ModHelperText AddField(ModHelperWindow window, string name, float x, float y, float width, float height, string text, float fontSize)
		{
			//IL_0017: 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)
			((ModHelperComponent)window.content).AddImage(TableInfo(name + "Panel", x, y, width, height), ModContent.GetSpriteReference<ChaosMonkeyMod>("ChaosTextField").guidRef);
			ModHelperText obj = ((ModHelperComponent)window.content).AddText(TableInfo(name, x, y, width - 18f, height - 5f), text, fontSize * 1.35f, (TextAlignmentOptions)514);
			obj.EnableAutoSizing(fontSize * 1.35f, 16.2f);
			return obj;
		}

		private static Info TableInfo(string name, float x, float y, float width, float height)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			return new Info(name, x * 1.35f, y * 1.35f, width * 1.35f, height * 1.35f);
		}

		private static string BuildLuckText()
		{
			ChaosMonkeyMatchState match = ChaosMonkeyMod.Session.Match;
			if (match != null)
			{
				return $"CURRENT LUCK ×{match.PurchasedLuck}";
			}
			return "CURRENT LUCK ×—";
		}

		private static string BuildNextLuckText()
		{
			int? nextLuck = GetNextLuck();
			if (nextLuck.HasValue)
			{
				return $"BUY LUCK ×{nextLuck.Value} • ${ChaosEconomy.LuckCashCosts[nextLuck.Value]:N0}";
			}
			return "LUCK MAXIMUM ×2048";
		}

		private string BuildOddsText(Rarity rarity)
		{
			int luckMultiplier = ChaosMonkeyMod.Session.Match?.PurchasedLuck ?? 1;
			IReadOnlyDictionary<Rarity, double> displayedOdds = gacha.GetDisplayedOdds(luckMultiplier);
			return $"{rarity.ToString().ToUpperInvariant()} • {displayedOdds[rarity]:0.000}%";
		}

		private static int? GetNextLuck()
		{
			int num = ChaosMonkeyMod.Session.Match?.PurchasedLuck ?? 1;
			for (int i = 0; i < ChaosEconomy.PurchasableLuck.Count - 1; i++)
			{
				if (ChaosEconomy.PurchasableLuck[i] == num)
				{
					return ChaosEconomy.PurchasableLuck[i + 1];
				}
			}
			return null;
		}
	}
	internal static class ChaosMonkeyAppearance
	{
		private readonly record struct LayerLayout(string TextureName, Vector3 Position, Vector3 Scale, float Rotation, int SortingOrder);

		private readonly record struct AnimatedEvolutionPart(Transform Transform, Vector3 BaseScale, bool Pulses);

		private const string RootName = "ChaosMonkeyLoadoutVisual";

		private const float PixelsPerUnit = 420f;

		private static readonly IReadOnlyDictionary<EquipmentSlot, LayerLayout> Layouts = new Dictionary<EquipmentSlot, LayerLayout>
		{
			[EquipmentSlot.Weapon] = new LayerLayout("SlotWeaponIcon", new Vector3(0.58f, 0.08f, -0.3f), new Vector3(0.54f, 0.54f, 1f), -12f, 30),
			[EquipmentSlot.Ammo] = new LayerLayout("SlotAmmoIcon", new Vector3(-0.44f, -0.2f, -0.25f), new Vector3(0.38f, 0.38f, 1f), 16f, 40),
			[EquipmentSlot.Body] = new LayerLayout("SlotBodyIcon", new Vector3(0f, -0.06f, -0.2f), new Vector3(0.48f, 0.48f, 1f), 0f, 50),
			[EquipmentSlot.Head] = new LayerLayout("SlotHeadIcon", new Vector3(0f, 0.55f, -0.2f), new Vector3(0.46f, 0.46f, 1f), 0f, 60),
			[EquipmentSlot.Trait] = new LayerLayout("SlotTraitIcon", new Vector3(-0.62f, 0.42f, -0.35f), new Vector3(0.34f, 0.34f, 1f), 12f, 70),
			[EquipmentSlot.Ability] = new LayerLayout("SlotAbilityIcon", new Vector3(0f, -0.08f, 0.4f), new Vector3(0.68f, 0.68f, 1f), 0f, 10)
		};

		private static Tower? activeTower;

		private static UnityDisplayNode? activeDisplayNode;

		private static SpriteRenderer? pulseRenderer;

		private static float pulseEndsAt;

		private static Transform? evolutionRig;

		private static readonly List<AnimatedEvolutionPart> evolutionOrbitParts = new List<AnimatedEvolutionPart>();

		private static readonly List<Material> evolutionMaterials = new List<Material>();

		private static bool evolutionUsesMesh;

		private static bool evolutionUsesTowerDisplay;

		private static float evolutionOrbitTime;

		private static float nextEvolutionIntegrityCheckAt;

		private static EvolutionKind? appliedEvolutionDisplay;

		internal static void Attach(Tower tower)
		{
			activeTower = tower;
			ChaosMonkeyCombat.Apply(tower);
			Rebuild(celebrate: false, null);
		}

		internal static bool IsAttachedTo(Tower tower)
		{
			if (activeTower != null)
			{
				return activeTower == tower;
			}
			return false;
		}

		internal static void RegisterGraphics(IReadOnlyList<UnityDisplayNode> nodes)
		{
			activeDisplayNode = ((IEnumerable<UnityDisplayNode>)nodes).FirstOrDefault((Func<UnityDisplayNode, bool>)((UnityDisplayNode node) => (Object)(object)node != (Object)null));
			ModHelper.Msg<ChaosMonkeyMod>((object)$"Chaos graphics captured: {nodes.Count} node(s), live node: {(Object)(object)activeDisplayNode != (Object)null}.");
			if (activeTower != null)
			{
				Rebuild(celebrate: false, null);
			}
		}

		internal static void RefreshAfterRoll(RollResult result)
		{
			if (activeTower != null)
			{
				ChaosMonkeyCombat.Apply(activeTower);
			}
			Rebuild(celebrate: true, result);
		}

		internal static void RefreshAfterDeveloperLoadout()
		{
			if (activeTower != null)
			{
				ChaosMonkeyCombat.Apply(activeTower);
			}
			Rebuild(celebrate: false, null);
		}

		internal static void RefreshAfterEvolution()
		{
			if (activeTower != null)
			{
				ChaosMonkeyCombat.Apply(activeTower);
			}
			Rebuild(celebrate: false, null);
		}

		internal static void RefreshForSelection(Tower tower)
		{
			activeTower = tower;
			Rebuild(celebrate: false, null);
		}

		internal static void Reset()
		{
			activeTower = null;
			activeDisplayNode = null;
			pulseRenderer = null;
			pulseEndsAt = 0f;
			evolutionRig = null;
			evolutionOrbitParts.Clear();
			DisposeEvolutionMaterials();
			evolutionUsesMesh = false;
			evolutionUsesTowerDisplay = false;
			evolutionOrbitTime = 0f;
			nextEvolutionIntegrityCheckAt = 0f;
			appliedEvolutionDisplay = null;
		}

		internal static bool TrySellActiveTower()
		{
			if (activeTower == null)
			{
				return false;
			}
			TowerExt.SellTower(activeTower);
			return true;
		}

		internal static void Tick()
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: 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_00ba: Unknown result type (might be due to invalid IL or missing references)
			EnsureEvolutionVisualIsAttached();
			TickSecretEvolutionRig();
			if (pulseRenderer != null)
			{
				if (Time.time >= pulseEndsAt)
				{
					Object.Destroy((Object)(object)((Component)pulseRenderer).gameObject);
					pulseRenderer = null;
					return;
				}
				float num = 1f - (pulseEndsAt - Time.time) / 1.2f;
				float num2 = 0.75f + num * 1.15f;
				Color color = pulseRenderer.color;
				color.a = (1f - num) * 0.72f;
				pulseRenderer.color = color;
				((Component)pulseRenderer).transform.localScale = new Vector3(num2, num2, 1f);
				((Component)pulseRenderer).transform.localEulerAngles = new Vector3(0f, 0f, num * 220f);
			}
		}

		private static void Rebuild(bool celebrate, RollResult? result)
		{
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Expected O, but got Unknown
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			if (activeTower == null || !ChaosMonkeyMod.Session.IsChaosMonkeyPresent)
			{
				return;
			}
			try
			{
				ChaosMonkeyMatchState match = ChaosMonkeyMod.Session.Match;
				UnityDisplayNode liveDisplayNode = GetLiveDisplayNode();
				if ((Object)(object)liveDisplayNode == (Object)null)
				{
					return;
				}
				Transform transform = ((Component)liveDisplayNode).transform;
				SetBaseRenderersVisible(transform, visible: true);
				Transform val = transform.Find("ChaosMonkeyLoadoutVisual");
				if (val != null)
				{
					Object.Destroy((Object)(object)((Component)val).gameObject);
				}
				DisposeEvolutionMaterials();
				evolutionRig = null;
				evolutionOrbitParts.Clear();
				evolutionOrbitTime = 0f;
				nextEvolutionIntegrityCheckAt = Time.time + 0.45f;
				Renderer val2 = ((IEnumerable<Renderer>)((Component)transform).GetComponentsInChildren<Renderer>(true)).FirstOrDefault((Func<Renderer, bool>)((Renderer renderer) => renderer != null && !((Object)((Component)renderer).gameObject).name.StartsWith("ChaosMonkeyLoadoutVisual", StringComparison.Ordinal)));
				ModHelper.Msg<ChaosMonkeyMod>((object)$"Chaos display renderer scan: {val2 != null} visible renderer anchor.");
				int num = ((val2 == null) ? ((Component)transform).gameObject.layer : ((Component)val2).gameObject.layer);
				GameObject val3 = new GameObject("ChaosMonkeyLoadoutVisual");
				val3.transform.SetParent(transform, false);
				val3.layer = num;
				val3.transform.localPosition = new Vector3(0f, 0f, -0.1f);
				if (match != null && match.Evolution.IsComplete)
				{
					ChaosEvolutionDisplayMaterials.CaptureTowerMaterial(GetLiveDisplayNode());
					if (!TryApplyEvolutionTowerDisplay(match.Evolution.Kind))
					{
						AddStableEvolutionVisual(val3.transform, match.Evolution.Kind, num);
					}
					return;
				}
				appliedEvolutionDisplay = null;
				evolutionUsesTowerDisplay = false;
				if (match != null)
				{
					foreach (KeyValuePair<EquipmentSlot, LayerLayout> layout in Layouts)
					{
						layout.Deconstruct(out var key, out var value);
						EquipmentSlot equipmentSlot = key;
						LayerLayout layerLayout = value;
						ItemDefinition item = match.GetItem(equipmentSlot);
						if ((object)item != null)
						{
							AddLayer(val3.transform, $"ChaosMonkey{equipmentSlot}{item.Id}", item, layerLayout.Position, layerLayout.Scale, layerLayout.Rotation, layerLayout.SortingOrder);
						}
					}
				}
				if (celebrate && (object)result != null)
				{
					AddRollPulse(val3.transform, result.Item);
				}
			}
			catch (Exception ex)
			{
				ModHelper.Error<ChaosMonkeyMod>((object)("Could not refresh Chaos Monkey appearance: " + ex.Message));
			}
		}

		private static void AddStableEvolutionVisual(Transform parent, EvolutionKind kind, int visibleLayer)
		{
			//IL_0031: 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_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_005f: 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_006f: 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_0083: 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)
			GameObject val = new GameObject($"ChaosMonkey{kind}EvolutionVisual");
			val.transform.SetParent(parent, false);
			val.layer = visibleLayer;
			val.transform.localPosition = new Vector3(0f, 0f, -0.22f);
			val.transform.localScale = Vector3.one * 0.82f;
			SpriteRenderer obj = val.AddComponent<SpriteRenderer>();
			obj.sprite = ModContent.GetSprite<ChaosMonkeyMod>((kind == EvolutionKind.SecretAscension) ? "ChaosMonkeySecretEvolution" : "ChaosMonkeyGodlyEvolution", 950f);
			obj.color = Color.white;
			((Renderer)obj).sortingOrder = 250;
			evolutionRig = val.transform;
			evolutionOrbitParts.Clear();
			evolutionOrbitTime = 0f;
			evolutionUsesMesh = false;
			evolutionUsesTowerDisplay = false;
			appliedEvolutionDisplay = kind;
			ModHelper.Msg<ChaosMonkeyMod>((object)$"Attached stable {kind} evolution visual without loading a runtime AssetBundle.");
		}

		private static bool TryAddBundledEvolutionVisual(Transform parent, EvolutionKind kind, int visibleLayer, Renderer? materialAnchor)
		{
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Expected O, but got Unknown
			try
			{
				if (((materialAnchor != null) ? materialAnchor.sharedMaterial : null) == null)
				{
					ModHelper.Warning<ChaosMonkeyMod>((object)"Evolution mesh is waiting for a live BTD6 material; using the safe fallback.");
					return false;
				}
				string text = ((kind == EvolutionKind.SecretAscension) ? "ChaosMonkeySecretEvolution" : "ChaosMonkeyGodlyEvolution");
				GameObject val = AssetBundleExt.LoadAssetSync<GameObject>(ModContent.GetBundle<ChaosMonkeyMod>("chaosmonkeyevolutions"), text);
				if ((Object)(object)val == (Object)null)
				{
					ModHelper.Warning<ChaosMonkeyMod>((object)("Evolution mesh prefab " + text + " was not found; using the safe fallback."));
					return false;
				}
				GameObject val2 = Object.Instantiate<GameObject>(val);
				((Object)val2).name = $"ChaosMonkey{kind}EvolutionMesh";
				val2.transform.SetParent(parent, false);
				val2.transform.localPosition = new Vector3(0f, -0.4f, -0.72f);
				val2.transform.localScale = Vector3.one * 0.46f;
				SetLayerRecursively(val2.transform, visibleLayer);
				Il2CppArrayBase<MeshRenderer> componentsInChildren = val2.GetComponentsInChildren<MeshRenderer>(true);
				if (componentsInChildren.Length == 0)
				{
					Object.Destroy((Object)(object)val2);
					ModHelper.Warning<ChaosMonkeyMod>((object)("Evolution mesh prefab " + text + " has no meshes; using the safe fallback."));
					return false;
				}
				foreach (MeshRenderer item in componentsInChildren)
				{
					Shader val3 = Shader.Find("Unlit/Color");
					Material val4 = ((val3 == null) ? new Material(materialAnchor.sharedMaterial) : new Material(val3));
					evolutionMaterials.Add(val4);
					((Renderer)item).sharedMaterial = val4;
					ApplyEvolutionPartColor(val4, kind, ((Object)((Component)item).gameObject).name);
					val4.renderQueue = 4000;
					if (val4.HasProperty("_Cull"))
					{
						val4.SetInt("_Cull", 0);
					}
					((Renderer)item).enabled = true;
				}
				evolutionRig = val2.transform;
				evolutionOrbitParts.Clear();
				evolutionOrbitTime = 0f;
				evolutionUsesMesh = true;
				evolutionUsesTowerDisplay = false;
				appliedEvolutionDisplay = kind;
				ModHelper.Msg<ChaosMonkeyMod>((object)$"Attached clean native 3D {kind} evolution mesh ({componentsInChildren.Length} parts).");
				return true;
			}
			catch (Exception ex)
			{
				DisposeEvolutionMaterials();
				ModHelper.Error<ChaosMonkeyMod>((object)("Could not attach the clean 3D evolution mesh: " + ex.Message));
				return false;
			}
		}

		private static void ApplyEvolutionPartColor(Material material, EvolutionKind kind, string partName)
		{
			//IL_000f: 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_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			Color val = ((kind == EvolutionKind.SecretAscension) ? GetSecretEvolutionColor(partName) : GetGodlyEvolutionColor(partName));
			if (material.HasProperty("_Color"))
			{
				material.SetColor("_Color", val);
			}
			if (material.HasProperty("_BaseColor"))
			{
				material.SetColor("_BaseColor", val);
			}
		}

		private static bool TryApplyEvolutionTowerDisplay(EvolutionKind kind)
		{
			if (activeTower == null)
			{
				return false;
			}
			if (evolutionUsesTowerDisplay && appliedEvolutionDisplay == kind)
			{
				return true;
			}
			try
			{
				TowerModel val = TowerModelExt.MakeCopy(activeTower.towerModel, $"ChaosMonkey{kind}EvolutionRuntime", false, ((EntityModel)activeTower.towerModel).baseId);
				if (kind == EvolutionKind.SecretAscension)
				{
					TowerModelExt.SetDisplay<ChaosMonkeySecretEvolutionDisplay>(val);
				}
				else
				{
					TowerModelExt.SetDisplay<ChaosMonkeyGodlyEvolutionDisplay>(val);
				}
				activeDisplayNode = null;
				TowerExt.SetTowerModel(activeTower, val);
				evolutionRig = null;
				evolutionOrbitParts.Clear();
				evolutionUsesMesh = false;
				evolutionUsesTowerDisplay = true;
				appliedEvolutionDisplay = kind;
				ModHelper.Msg<ChaosMonkeyMod>((object)$"Applied {kind} through BTD6's native tower display pipeline.");
				return true;
			}
			catch (Exception ex)
			{
				evolutionUsesTowerDisplay = false;
				ModHelper.Error<ChaosMonkeyMod>((object)("Could not apply the native evolution tower display: " + ex.Message));
				return false;
			}
		}

		private static Color GetGodlyEvolutionColor(string partName)
		{
			//IL_0022: 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_00aa: 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_0108: Unknown result type (might be due to invalid IL or missing references)
			if (partName.Contains("Eye", StringComparison.Ordinal))
			{
				return new Color(0.08f, 0.92f, 1f, 1f);
			}
			if (partName.Contains("Crystal", StringComparison.Ordinal) || partName.Contains("Gem", StringComparison.Ordinal) || partName.Contains("Core", StringComparison.Ordinal))
			{
				return new Color(0.95f, 0.18f, 1f, 1f);
			}
			if (partName.Contains("Crown", StringComparison.Ordinal) || partName.Contains("Halo", StringComparison.Ordinal) || partName.Contains("Staff", StringComparison.Ordinal))
			{
				return new Color(1f, 0.72f, 0.1f, 1f);
			}
			if (partName.Contains("Robe", StringComparison.Ordinal) || partName.Contains("Cape", StringComparison.Ordinal) || partName.Contains("Hood", StringComparison.Ordinal))
			{
				return new Color(0.31f, 0.06f, 0.62f, 1f);
			}
			return new Color(0.47f, 0.2f, 0.09f, 1f);
		}

		private static Color GetSecretEvolutionColor(string partName)
		{
			//IL_0022: 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_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: 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)
			if (partName.Contains("Eye", StringComparison.Ordinal))
			{
				return new Color(0.12f, 0.94f, 1f, 1f);
			}
			if (partName.Contains("Crystal", StringComparison.Ordinal) || partName.Contains("Core", StringComparison.Ordinal) || partName.Contains("Planet", StringComparison.Ordinal))
			{
				return new Color(0.86f, 0.07f, 1f, 1f);
			}
			if (partName.Contains("Halo", StringComparison.Ordinal) || partName.Contains("Staff", StringComparison.Ordinal))
			{
				return new Color(0.2f, 0.04f, 0.48f, 1f);
			}
			if (partName.Contains("Robe", StringComparison.Ordinal) || partName.Contains("Cape", StringComparison.Ordinal) || partName.Contains("Crown", StringComparison.Ordinal))
			{
				return new Color(0.035f, 0.008f, 0.1f, 1f);
			}
			return new Color(0.055f, 0.012f, 0.14f, 1f);
		}

		private static void SetBaseRenderersVisible(Transform displayTransform, bool visible)
		{
			Transform val = displayTransform.Find("ChaosMonkeyLoadoutVisual");
			foreach (Renderer componentsInChild in ((Component)displayTransform).GetComponentsInChildren<Renderer>(true))
			{
				if (val == null || !((Component)componentsInChild).transform.IsChildOf(val))
				{
					componentsInChild.enabled = visible;
				}
			}
		}

		private static void SetLayerRecursively(Transform transform, int layer)
		{
			((Component)transform).gameObject.layer = layer;
			for (int i = 0; i < transform.childCount; i++)
			{
				SetLayerRecursively(transform.GetChild(i), layer);
			}
		}

		private static void DisposeEvolutionMaterials()
		{
			foreach (Material evolutionMaterial in evolutionMaterials)
			{
				if ((Object)(object)evolutionMaterial != (Object)null)
				{
					Object.Destroy((Object)(object)evolutionMaterial);
				}
			}
			evolutionMaterials.Clear();
		}

		private static void AddLayer(Transform parent, string name, ItemDefinition item, Vector3 position, Vector3 scale, float rotation, int sortingOrder, float pixelsPerUnit = 420f)
		{
			//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_0013: 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_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_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: 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_006c: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			val.layer = ((Component)parent).gameObject.layer;
			val.transform.localPosition = position;
			val.transform.localScale = scale;
			val.transform.localEulerAngles = new Vector3(0f, 0f, rotation);
			SpriteRenderer obj = val.AddComponent<SpriteRenderer>();
			obj.sprite = ChaosItemArtwork.GetSprite(item);
			obj.color = ChaosItemArtwork.GetTint(item);
			((Renderer)obj).sortingOrder = sortingOrder;
		}

		private static void AddRollPulse(Transform root, ItemDefinition item)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: 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_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: 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)
			GameObject val = new GameObject("ChaosMonkeyRollPulse");
			val.transform.SetParent(root, false);
			val.layer = ((Component)root).gameObject.layer;
			val.transform.localPosition = new Vector3(0f, 0f, 0.6f);
			val.transform.localScale = new Vector3(0.75f, 0.75f, 1f);
			pulseRenderer = val.AddComponent<SpriteRenderer>();
			pulseRenderer.sprite = ModContent.GetSprite<ChaosMonkeyMod>("SlotAbilityIcon", 420f);
			Color itemColor = GetItemColor(item);
			itemColor.a = 0.72f;
			pulseRenderer.color = itemColor;
			((Renderer)pulseRenderer).sortingOrder = 100;
			pulseEndsAt = Time.time + 1.2f;
		}

		private static void AddSecretEvolutionRig(Transform parent, UnityDisplayNode displayNode)
		{
			//IL_0015: 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_002a: Expected O, but got Unknown
			//IL_005d: 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_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: 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_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: 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_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: 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_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			TintVanillaMonkey(displayNode, new Color(0.12f, 0.03f, 0.28f, 1f));
			GameObject val = new GameObject("ChaosMonkeySecretEvolution3DRig");
			val.transform.SetParent(parent, false);
			val.layer = ((Component)parent).gameObject.layer;
			val.transform.localPosition = new Vector3(0f, 0.03f, 0.25f);
			evolutionRig = val.transform;
			RegisterAnimatedPart(CreateEvolutionMesh("SecretVoidCore", (PrimitiveType)0, val.transform, new Vector3(0f, -0.02f, 0.35f), new Vector3(0.52f, 0.52f, 0.52f), new Color(0.035f, 0.008f, 0.1f, 1f)), pulse: false);
			CreateEvolutionMesh("SecretGalaxyHalo", (PrimitiveType)2, val.transform, new Vector3(0f, -0.04f, 0.2f), new Vector3(1.35f, 0.035f, 1.35f), new Color(0.18f, 0.02f, 0.42f, 0.85f)).transform.localEulerAngles = new Vector3(68f, 0f, 0f);
			Color[] array = (Color[])(object)new Color[6]
			{
				new Color(0.5f, 0.05f, 1f),
				new Color(0.05f, 0.82f, 1f),
				new Color(0.96f, 0.05f, 0.68f),
				new Color(0.16f, 0.03f, 0.35f),
				new Color(0.38f, 0.1f, 0.92f),
				new Color(0.05f, 0.46f, 0.92f)
			};
			for (int i = 0; i < array.Length; i++)
			{
				float num = (float)i * MathF.PI * 2f / (float)array.Length;
				GameObject obj = CreateEvolutionMesh($"SecretOrbitCrystal{i}", (PrimitiveType)1, val.transform, new Vector3(Mathf.Cos(num) * 1.12f, Mathf.Sin(num) * 0.72f, -0.06f), new Vector3(0.18f, 0.3f, 0.18f), array[i]);
				obj.transform.localEulerAngles = new Vector3(35f, (float)i * 55f, (float)(-i) * 21f);
				RegisterAnimatedPart(obj, pulse: true);
			}
		}

		private static void AddGodlyEvolutionRig(Transform parent, UnityDisplayNode displayNode)
		{
			//IL_0015: 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_002a: Expected O, but got Unknown
			//IL_005d: 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_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: 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_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: 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_02ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0312: Unknown result type (might be due to invalid IL or missing references)
			//IL_0317: Unknown result type (might be due to invalid IL or missing references)
			//IL_0332: 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)
			//IL_0352: Unknown result type (might be due to invalid IL or missing references)
			//IL_0357: Unknown result type (might be due to invalid IL or missing references)
			//IL_0372: Unknown result type (might be due to invalid IL or missing references)
			//IL_0377: Unknown result type (might be due to invalid IL or missing references)
			//IL_0392: Unknown result type (might be due to invalid IL or missing references)
			//IL_0397: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: 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_040d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0421: Unknown result type (might be due to invalid IL or missing references)
			//IL_0429: Unknown result type (might be due to invalid IL or missing references)
			//IL_0451: Unknown result type (might be due to invalid IL or missing references)
			TintVanillaMonkey(displayNode, new Color(0.66f, 0.25f, 0.98f, 1f));
			GameObject val = new GameObject("ChaosMonkeyGodlyEvolution3DRig");
			val.transform.SetParent(parent, false);
			val.layer = ((Component)parent).gameObject.layer;
			val.transform.localPosition = new Vector3(0f, 0.02f, 0.24f);
			evolutionRig = val.transform;
			CreateEvolutionMesh("GodlyCrownBand", (PrimitiveType)2, val.transform, new Vector3(0f, 0.7f, 0.05f), new Vector3(0.52f, 0.1f, 0.52f), new Color(1f, 0.7f, 0.08f, 1f)).transform.localEulerAngles = new Vector3(90f, 0f, 0f);
			for (int i = 0; i < 5; i++)
			{
				float num = (float)(i - 2) * 0.18f;
				RegisterAnimatedPart(CreateEvolutionMesh($"GodlyCrownCrystal{i}", (PrimitiveType)1, val.transform, new Vector3(num, 0.88f + (float)(i % 2) * 0.08f, 0.08f), new Vector3(0.11f, 0.28f, 0.11f), (i % 2 == 0) ? new Color(0.12f, 0.92f, 1f, 1f) : new Color(0.96f, 0.12f, 0.88f, 1f)), pulse: true);
			}
			RegisterAnimatedPart(CreateEvolutionMesh("GodlyChestCore", (PrimitiveType)0, val.transform, new Vector3(0f, 0.12f, 0.33f), new Vector3(0.34f, 0.34f, 0.2f), new Color(0.04f, 0.82f, 1f, 1f)), pulse: true);
			CreateEvolutionMesh("GodlyCrystalStaff", (PrimitiveType)2, val.transform, new Vector3(0.56f, 0.1f, 0.08f), new Vector3(0.08f, 0.72f, 0.08f), new Color(0.76f, 0.12f, 1f, 1f)).transform.localEulerAngles = new Vector3(0f, 0f, -28f);
			CreateEvolutionMesh("GodlyCrystalHalo", (PrimitiveType)2, val.transform, new Vector3(0f, 0.22f, 0.02f), new Vector3(1.22f, 0.025f, 1.22f), new Color(1f, 0.64f, 0.08f, 1f)).transform.localEulerAngles = new Vector3(68f, 0f, 0f);
			Color[] array = (Color[])(object)new Color[6]
			{
				new Color(0.08f, 0.92f, 1f, 1f),
				new Color(0.98f, 0.2f, 0.88f, 1f),
				new Color(0.4f, 1f, 0.22f, 1f),
				new Color(1f, 0.68f, 0.05f, 1f),
				new Color(0.48f, 0.18f, 1f, 1f),
				new Color(0.92f, 0.94f, 1f, 1f)
			};
			for (int j = 0; j < array.Length; j++)
			{
				float num2 = (float)j * MathF.PI * 2f / (float)array.Length;
				GameObject obj = CreateEvolutionMesh($"GodlyOrbitCrystal{j}", (PrimitiveType)1, val.transform, new Vector3(Mathf.Cos(num2) * 0.98f, 0.2f + Mathf.Sin(num2) * 0.6f, -0.08f), new Vector3(0.15f, 0.29f, 0.15f), array[j]);
				obj.transform.localEulerAngles = new Vector3(42f, (float)j * 56f, (float)(-j) * 23f);
				RegisterAnimatedPart(obj, pulse: true);
			}
		}

		private static GameObject CreateEvolutionMesh(string name, PrimitiveType type, Transform parent, Vector3 position, Vector3 scale, Color color)
		{
			//IL_0000: 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_0041: 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_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = GameObject.CreatePrimitive(type);
			((Object)obj).name = name;
			obj.transform.SetParent(parent, false);
			obj.layer = ((Component)parent).gameObject.layer;
			obj.transform.localPosition = position + new Vector3(0f, 0f, -0.75f);
			obj.transform.localScale = scale;
			Collider component = obj.GetComponent<Collider>();
			if (component != null)
			{
				Object.Destroy((Object)(object)component);
			}
			Renderer component2 = obj.GetComponent<Renderer>();
			if (component2 != null)
			{
				Shader val = Shader.Find("Unlit/Color");
				if (val != null)
				{
					component2.material = new Material(val);
				}
				if (component2.material != null)
				{
					component2.material.renderQueue = 4000;
					if (component2.material.HasProperty("_Color"))
					{
						component2.material.color = color;
					}
				}
				component2.enabled = true;
			}
			return obj;
		}

		private static void TintVanillaMonkey(UnityDisplayNode displayNode, Color tint)
		{
			//IL_0039: 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)
			foreach (Renderer componentsInChild in ((Component)displayNode).GetComponentsInChildren<Renderer>(true))
			{
				if (((Object)((Component)componentsInChild).gameObject).name.StartsWith("ChaosMonkeyLoadoutVisual", StringComparison.Ordinal))
				{
					continue;
				}
				SpriteRenderer val = (SpriteRenderer)(object)((componentsInChild is SpriteRenderer) ? componentsInChild : null);
				if (val != null)
				{
					val.color = tint;
					continue;
				}
				Material material = componentsInChild.material;
				if (material != null && material.HasProperty("_Color"))
				{
					material.color = tint;
				}
			}
		}

		private static void ApplyNativeEvolutionColor(EvolutionKind kind)
		{
			//IL_004a: 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_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: 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_0070: Unknown result type (might be due to invalid IL or missing references)
			if (activeTower != null)
			{
				DisplayNode displayNode = TowerExt.GetDisplayNode(activeTower);
				if (displayNode != null)
				{
					Color val = ((kind == EvolutionKind.SecretAscension) ? new Color(0.1f, 0.02f, 0.24f, 1f) : new Color(0.72f, 0.22f, 0.98f, 1f));
					displayNode.modifyColor = true;
					displayNode.colorRed = val.r;
					displayNode.colorGreen = val.g;
					displayNode.colorBlue = val.b;
				}
			}
		}

		private static void ClearNativeEvolutionColor()
		{
			if (activeTower != null)
			{
				DisplayNode displayNode = TowerExt.GetDisplayNode(activeTower);
				if (displayNode != null)
				{
					displayNode.modifyColor = false;
				}
			}
		}

		private static void RegisterAnimatedPart(GameObject part, bool pulse)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			evolutionOrbitParts.Add(new AnimatedEvolutionPart(part.transform, part.transform.localScale, pulse));
		}

		private static void TickSecretEvolutionRig()
		{
			//IL_009c: 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_00cd: 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_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)evolutionRig == (Object)null)
			{
				evolutionRig = null;
				evolutionOrbitParts.Clear();
				return;
			}
			evolutionOrbitTime += Time.deltaTime;
			if (evolutionUsesMesh)
			{
				evolutionRig.localEulerAngles = new Vector3(Mathf.Sin(evolutionOrbitTime * 0.75f) * 4f, Mathf.Sin(evolutionOrbitTime * 0.55f) * 7f, 0f);
			}
			else
			{
				evolutionRig.localEulerAngles = new Vector3(0f, 0f, Mathf.Sin(evolutionOrbitTime * 0.75f) * 3f);
			}
			for (int i = 0; i < evolutionOrbitParts.Count; i++)
			{
				AnimatedEvolutionPart animatedEvolutionPart = evolutionOrbitParts[i];
				if (animatedEvolutionPart.Transform != null)
				{
					Transform transform = animatedEvolutionPart.Transform;
					transform.localEulerAngles += new Vector3(46f, 96f + (float)i * 13f, 72f) * Time.deltaTime;
					if (animatedEvolutionPart.Pulses)
					{
						float num = 1f + Mathf.Sin(evolutionOrbitTime * 3.2f + (float)i) * 0.1f;
						animatedEvolutionPart.Transform.localScale = animatedEvolutionPart.BaseScale * num;
					}
				}
			}
		}

		private static void EnsureEvolutionVisualIsAttached()
		{
			ChaosMonkeyMatchState match = ChaosMonkeyMod.Session.Match;
			if (activeTower == null || match == null || !match.Evolution.IsComplete || Time.time < nextEvolutionIntegrityCheckAt)
			{
				return;
			}
			nextEvolutionIntegrityCheckAt = Time.time + 0.45f;
			try
			{
				if (appliedEvolutionDisplay != match.Evolution.Kind || (!evolutionUsesTowerDisplay && (Object)(object)evolutionRig == (Object)null))
				{
					Rebuild(celebrate: false, null);
				}
			}
			catch (Exception ex)
			{
				ModHelper.Error<ChaosMonkeyMod>((object)("Could not restore Chaos Monkey evolution visual: " + ex.Message));
			}
		}

		private static UnityDisplayNode? GetLiveDisplayNode()
		{
			if ((Object)(object)activeDisplayNode != (Object)null)
			{
				return activeDisplayNode;
			}
			if (activeTower == null)
			{
				return null;
			}
			DisplayNode displayNode = TowerExt.GetDisplayNode(activeTower);
			if ((Object)(object)((displayNode != null) ? displayNode.graphic : null) != (Object)null)
			{
				activeDisplayNode = displayNode.graphic;
				ModHelper.Msg<ChaosMonkeyMod>((object)"Chaos Monkey live display acquired from its simulation node.");
				return activeDisplayNode;
			}
			UnityDisplayNode unityDisplayNode = TowerExt.GetUnityDisplayNode(activeTower);
			if ((Object)(object)unityDisplayNode != (Object)null)
			{
				activeDisplayNode = unityDisplayNode;
				ModHelper.Msg<ChaosMonkeyMod>((object)"Chaos Monkey live display acquired through the tower bridge.");
				return activeDisplayNode;
			}
			return null;
		}

		internal static Color GetItemColor(ItemDefinition item)
		{
			//IL_0041: 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_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)
			//IL_0075: 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_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: 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_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: 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_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: 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_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: 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_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_029f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0314: Unknown result type (might be due to invalid IL or missing references)
			//IL_033b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0362: Unknown result type (might be due to invalid IL or missing references)
			//IL_038f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0389: Unknown result type (might be due to invalid IL or missing references)
			Color result = (Color)(item.Rarity switch
			{
				Rarity.Common => new Color(0.82f, 0.84f, 0.88f), 
				Rarity.Uncommon => new Color(0.4f, 1f, 0.52f), 
				Rarity.Rare => new Color(0.22f, 0.72f, 1f), 
				Rarity.Epic => new Color(0.82f, 0.27f, 1f), 
				Rarity.Legendary => new Color(1f, 0.42f, 0.1f), 
				Rarity.Mythic => new Color(1f, 0.12f, 0.5f), 
				Rarity.Godly => new Color(1f, 0.84f, 0.22f), 
				Rarity.Secret => new Color(1f, 0.04f, 0.25f), 
				_ => Color.white, 
			});
			if (item.Tags.Contains("Fire"))
			{
				return new Color(1f, 0.28f, 0.06f);
			}
			if (item.Tags.Contains("Frost"))
			{
				return new Color(0.32f, 0.88f, 1f);
			}
			if (item.Tags.Contains("Lightning"))
			{
				return new Color(0.18f, 0.92f, 1f);
			}
			if (item.Tags.Contains("Gravity"))
			{
				return new Color(0.38f, 0.25f, 1f);
			}
			if (item.Tags.Contains("Void"))
			{
				return new Color(0.7f, 0.12f, 1f);
			}
			if (item.Tags.Contains("Poison"))
			{
				return new Color(0.34f, 0.94f, 0.2f);
			}
			if (item.Tags.Contains("Meteor"))
			{
				return new Color(1f, 0.48f, 0.08f);
			}
			if (item.Tags.Contains("Soul"))
			{
				return new Color(0.2f, 1f, 0.78f);
			}
			if (item.Tags.Contains("Time"))
			{
				return new Color(1f, 0.74f, 0.12f);
			}
			if (item.Tags.Contains("Reality"))
			{
				return new Color(1f, 0.18f, 0.64f);
			}
			if (item.Tags.Contains("Genesis"))
			{
				return new Color(1f, 0.95f, 0.42f);
			}
			if (item.Tags.Contains("Celestial"))
			{
				return new Color(0.72f, 0.92f, 1f);
			}
			if (item.Tags.Contains("Oblivion"))
			{
				return new Color(0.5f, 0.05f, 0.72f);
			}
			if (item.Tags.Contains("Luck"))
			{
				return new Color(0.36f, 1f, 0.58f);
			}
			if (item.Tags.Contains("Moab"))
			{
				return new Color(1f, 0.52f, 0.15f);
			}
			if (item.Tags.Contains("Galaxy"))
			{
				return new Color(0.2f, 0.82f, 1f);
			}
			if (item.Tags.Contains("Secret"))
			{
				return new Color(0.62f, 0.08f, 1f);
			}
			return result;
		}
	}
	internal static class ChaosMonkeyCombat
	{
		internal static void Apply(Tower tower)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Expected O, but got Unknown
			ChaosMonkeyMatchState match = ChaosMonkeyMod.Session.Match;
			if (match == null)
			{
				return;
			}
			try
			{
				ChaosCombatStats chaosCombatStats = ChaosCombatBalance.Calculate(match.Equipment, ChaosMonkeyMod.Session.ActiveSynergies, match.Evolution);
				TowerModel towerModel = tower.towerModel;
				OverrideCamoDetectionModel behavior = TowerModelBehaviorExt.GetBehavior<OverrideCamoDetectionModel>(towerModel);
				if (behavior == null)
				{
					TowerModelBehaviorExt.AddBehavior<OverrideCamoDetectionModel>(towerModel, new OverrideCamoDetectionModel("ChaosMonkeyAlwaysDetectsCamo", true));
				}
				else
				{
					behavior.detectCamo = true;
				}
				AttackModel behavior2 = TowerModelBehaviorExt.GetBehavior<AttackModel>(towerModel);
				if (behavior2 == null || ((Il2CppArrayBase<WeaponModel>)(object)behavior2.weapons).Length == 0)
				{
					return;
				}
				towerModel.range = chaosCombatStats.Range;
				behavior2.range = chaosCombatStats.Range;
				FilterInvisibleModel behavior3 = AttackModelBehaviorExt.GetBehavior<FilterInvisibleModel>(behavior2);
				if (behavior3 == null)
				{
					AttackModelBehaviorExt.AddBehavior<FilterInvisibleModel>(behavior2, new FilterInvisibleModel("ChaosMonkeyCamoTargeting", true, false));
				}
				else
				{
					behavior3.isActive = true;
				}
				match.Equipment.TryGetValue(EquipmentSlot.Weapon, out ItemDefinition value);
				foreach (WeaponModel item in (Il2CppArrayBase<WeaponModel>)(object)behavior2.weapons)
				{
					item.Rate = chaosCombatStats.AttackCooldown;
					item.projectile.pierce = chaosCombatStats.Pierce;
					ProjectileModelExt.SetHitCamo(item.projectile, true);
					DamageModel behavior4 = ProjectileModelBehaviorExt.GetBehavior<DamageModel>(item.projectile);
					if (behavior4 != null)
					{
						behavior4.damage = chaosCombatStats.Damage;
						behavior4.immuneBloonProperties = (BloonProperties)0;
					}
					if ((object)value != null)
					{
						ChaosWeaponProjectileDisplays.Apply(value.Id, item.projectile);
					}
				}
			}
			catch (Exception ex)
			{
				ModHelper.Error<ChaosMonkeyMod>((object)("Could not apply Chaos Monkey combat gear: " + ex.Message));
			}
		}
	}
	public sealed class ChaosMonkeyDashboardWindow : ModWindow
	{
		private const float BoardScale = 1.5f;

		private const string PanelTexture = "ChaosGachaPanel";

		private const string TextFieldTexture = "ChaosTextField";

		private const string ShardIconTexture = "ChaosShardIcon";

		private readonly Dictionary<EquipmentSlot, ModHelperText> slotLabels = new Dictionary<EquipmentSlot, ModHelperText>();

		private readonly Dictionary<EquipmentSlot, ModHelperImage> slotImages = new Dictionary<EquipmentSlot, ModHelperImage>();

		private readonly Dictionary<RollMode, ModHelperText> rollLabels = new Dictionary<RollMode, ModHelperText>();

		private EquipmentSlot selectedSlot;

		private ModHelperText? shardText;

		private ModHelperText? luckText;

		private ModHelperText? pityText;

		private ModHelperText? evolutionText;

		private ModHelperText? detailsTitle;

		private ModHelperText? detailsStats;

		private ModHelperText? detailsEffect;

		private ModHelperText? detailsSynergy;

		private ModHelperText? resultText;

		private ModHelperText? sellText;

		private ModHelperImage? loadoutPortrait;

		private string lastResult = "SELECT A SLOT, THEN ROLL FOR ITS FIRST PIECE OF GEAR.";

		public override int DefaultWidth => 2250;

		public override int DefaultHeight => 1530;

		public override bool AllowMultiple => false;

		public override bool AllowResizing => false;

		public override Info WindowInfo
		{
			get
			{
				//IL_0035: 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_0061: 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)
				Info result = default(Info);
				((Info)(ref result))..ctor(((ModContent)this).Name);
				((Info)(ref result)).set_Width((float)((ModWindow)this).DefaultWidth);
				((Info)(ref result)).set_Height((float)((ModWindow)this).DefaultHeight);
				((Info)(ref result)).set_Anchor(new Vector2(0.5f, 0.5f));
				((Info)(ref result)).set_Pivot(new Vector2(0.5f, 0.5f));
				((Info)(ref result)).set_Position(new Vector2(-235f, 0f));
				return result;
			}
		}

		public override void ModifyWindow(ModHelperWindow window)
		{
			//IL_001f: 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_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			((ModHelperComponent)window.content).AddImage(BoardInfo("ChaosGachaBoard", 0f, 0f, 1360f, 790f), ModContent.GetSpriteReference<ChaosMonkeyMod>("ChaosGachaPanel").guidRef);
			AddField(window, "BoardTitle", 0f, 333f, 420f, 48f, "CHAOS MONKEY • GEAR BOARD", 27f);
			((ModHelperComponent)window.content).AddImage(BoardInfo("BoardShardIcon", -225f, 279f, 46f, 46f), ModContent.GetSpriteReference<ChaosMonkeyMod>("ChaosShardIcon").guidRef);
			shardText = AddField(window, "BoardShards", -75f, 279f, 235f, 50f, BuildShardText(), 28f);
			luckText = AddField(window, "BoardLuck", 220f, 279f, 190f, 50f, BuildLuckText(), 24f);
			pityText = ((ModHelperComponent)window.content).AddText(BoardInfo("BoardPities", 0f, 218f, 720f, 55f), BuildPityText(), BoardFont(20f), (TextAlignmentOptions)514);
			pityText.EnableAutoSizing(BoardFont(20f), BoardFont(14f));
			evolutionText = AddField(window, "BoardEvolution", 0f, 154f, 690f, 52f, BuildEvolutionText(), 19f);
			AddSlotButton(window, EquipmentSlot.Weapon, -488f, 135f);
			AddSlotButton(window, EquipmentSlot.Body, -488f, -18f);
			AddSlotButton(window, EquipmentSlot.Trait, -488f, -171f);
			AddSlotButton(window, EquipmentSlot.Head, 488f, 135f);
			AddSlotButton(window, EquipmentSlot.Ammo, 488f, -18f);
			AddSlotButton(window, EquipmentSlot.Ability, 488f, -171f);
			loadoutPortrait = ((ModHelperComponent)window.content).AddImage(BoardInfo("ChaosMonkeyLoadoutPortrait", 0f, 5f, 215f, 265f), ModContent.GetSpriteReference<ChaosMonkeyMod>("ChaosMonkeyBaseUnarmed").guidRef);
			loadoutPortrait.Image.preserveAspect = true;
			detailsTitle = AddField(window, "SelectedItemTitle", 0f, -175f, 360f, 48f, BuildDetailsTitle(), 24f);
			detailsStats = AddField(window, "SelectedItemStats", 0f, -227f, 520f, 42f, BuildDetails().Stats, 19f);
			detailsEffect = AddField(window, "SelectedItemEffect", 0f, -278f, 710f, 52f, "EFFEKT: " + BuildDetails().Effect, 18f);
			detailsSynergy = AddField(window, "SelectedItemSynergy", 0f, -335f, 710f, 46f, "SYNERGIE: " + BuildDetails().Synergy, 17f);
			AddRollButton(window, "NormalRoll", -420f, "NORMAL ROLL", RollMode.Normal);
			AddRollButton(window, "RandomRoll", -420f, "RANDOM ROLL", RollMode.Random, -310f);
			AddRollButton(window, "SpecialRoll", -420f, "SPECIAL ROLL", RollMode.Special, 310f);
			resultText = AddField(window, "RollResult", 0f, -480f, 860f, 46f, lastResult, 18f);
			AddSellButton(window, -535f);
		}

		public override void OnUpdate(ModHelperWindow window)
		{
			//IL_009b: 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)
			ModHelperText? obj = shardText;
			if (obj != null)
			{
				obj.SetText(BuildShardText());
			}
			ModHelperText? obj2 = luckText;
			if (obj2 != null)
			{
				obj2.SetText(BuildLuckText());
			}
			ModHelperText? obj3 = pityText;
			if (obj3 != null)
			{
				obj3.SetText(BuildPityText());
			}
			ModHelperText? obj4 = evolutionText;
			if (obj4 != null)
			{
				obj4.SetText(BuildEvolutionText());
			}
			if (loadoutPortrait != null)
			{
				loadoutPortrait.Image.sprite = ModContent.GetSprite<ChaosMonkeyMod>(BuildPortraitAssetName(), 100f);
				loadoutPortrait.Image.preserveAspect = true;
				((Graphic)loadoutPortrait.Image).color = Color.white;
			}
			ModHelperText? obj5 = detailsTitle;
			if (obj5 != null)
			{
				obj5.SetText(BuildDetailsTitle());
			}
			ModHelperText? obj6 = detailsStats;
			if (obj6 != null)
			{
				obj6.SetText(BuildDetails().Stats);
			}
			ModHelperText? obj7 = detailsEffect;
			if (obj7 != null)
			{
				obj7.SetText("EFFEKT: " + BuildDetails().Effect);
			}
			ModHelperText? obj8 = detailsSynergy;
			if (obj8 != null)
			{
				obj8.SetText("SYNERGIE: " + BuildDetails().Synergy);
			}
			ModHelperText? obj9 = resultText;
			if (obj9 != null)
			{
				obj9.SetText(lastResult);
			}
			ModHelperText? obj10 = sellText;
			if (obj10 != null)
			{
				obj10.SetText(BuildSellText());
			}
			EquipmentSlot key;
			ModHelperText value;
			foreach (KeyValuePair<EquipmentSlot, ModHelperText> slotLabel in slotLabels)
			{
				slotLabel.Deconstruct(out key, out value);
				EquipmentSlot slot = key;
				value.SetText(BuildSlotText(slot));
			}
			foreach (KeyValuePair<EquipmentSlot, ModHelperImage> slotImage in slotImages)
			{
				slotImage.Deconstruct(out key, out var value2);
				EquipmentSlot slot2 = key;
				ModHelperImage val = value2;
				ItemDefinition itemDefinition = ChaosMonkeyMod.Session.Match?.GetItem(slot2);
				if ((object)itemDefinition != null)
				{
					val.Image.sprite = ChaosItemArtwork.GetSprite(itemDefinition);
					val.Image.preserveAspect = true;
					((Graphic)val.Image).color = ChaosItemArtwork.GetTint(itemDefinition);
				}
			}
			foreach (KeyValuePair<RollMode, ModHelperText> rollLabel in rollLabels)
			{
				rollLabel.Deconstruct(out var key2, out value);
				RollMode mode = key2;
				value.SetText(BuildRollText(mode));
			}
		}

		public override void OnClose(ModHelperWindow window)
		{
			shardText = null;
			luckText = null;
			pityText = null;
			evolutionText = null;
			detailsTitle = null;
			detailsStats = null;
			detailsEffect = null;
			detailsSynergy = null;
			resultText = null;
			sellText = null;
			loadoutPortrait = null;
			slotLabels.Clear();
			slotImages.Clear();
			rollLabels.Clear();
		}

		private void AddSlotButton(ModHelperWindow window, EquipmentSlot slot, float x, float y)
		{
			//IL_005d: 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_0182: 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)
			//IL_029c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0331: 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)
			((ModHelperComponent)window.content).AddImage(BoardInfo($"Slot{slot}Frame", x, y, 365f, 132f), ModContent.GetSpriteReference<ChaosMonkeyMod>("ChaosTextField").guidRef);
			ModHelperImage val = ((ModHelperComponent)window.content).AddImage(BoardInfo($"Slot{slot}Icon", x - 132f, y, 80f, 80f), ModContent.GetSpriteReference<ChaosMonkeyMod>($"Slot{slot}Icon").guidRef);
			val.Image.preserveAspect = true;
			slotImages[slot] = val;
			((ModHelperComponent)window.content).AddImage(BoardInfo($"Slot{slot}CostIcon", x + 81f, y - 39f, 28f, 28f), ModContent.GetSpriteReference<ChaosMonkeyMod>("ChaosShardIcon").guidRef);
			((ModHelperComponent)window.content).AddText(BoardInfo($"Slot{slot}Cost", x + 125f, y - 39f, 68f, 28f), ChaosEconomy.SlotRollCosts[slot].ToString(), BoardFont(18f), (TextAlignmentOptions)4097).EnableAutoSizing(BoardFont(18f), BoardFont(14f));
			slotLabels[slot] = ((ModHelperComponent)window.content).AddText(BoardInfo($"Slot{slot}Label", x + 36f, y + 8f, 254f, 82f), BuildSlotText(slot), BoardFont(20f), (TextAlignmentOptions)4097);
			slotLabels[slot].EnableAutoSizing(BoardFont(20f), BoardFont(14f));
			((Graphic)GameObjectExt.AddButton(((Component)window.content).gameObject, BoardInfo($"Slot{slot}", x, y, 365f, 132f), string.Empty, (Action)delegate
			{
				selectedSlot = slot;
				lastResult = ChaosItemDetailsCatalog.SlotName(slot) + " SELECTED • INSPECT THE ITEM EFFECT BELOW.";
			}).Image).color = new Color(1f, 1f, 1f, 0f);
		}

		private void AddRollButton(ModHelperWindow window, string name, float y, string label, RollMode mode, float x = 0f)
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			rollLabels[mode] = AddField(window, name + "Label", x, y, 250f, 72f, label, 21f);
			((Graphic)GameObjectExt.AddButton(((Component)window.content).gameObject, BoardInfo(name, x, y, 252f, 74f), string.Empty, (Action)delegate
			{
				Roll(mode);
			}).Image).color = new Color(1f, 1f, 1f, 0f);
		}

		private void AddSellButton(ModHelperWindow window, float y)
		{
			//IL_004b: 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)
			sellText = AddField(window, "SellResetLabel", 0f, y, 670f, 44f, BuildSellText(), 17f);
			((Graphic)GameObjectExt.AddButton(((Component)window.content).gameObject, BoardInfo("SellReset", 0f, y, 672f, 46f), string.Empty, (Action)delegate
			{
				if (ChaosMonkeyMod.TrySellActiveChaosMonkey())
				{
					lastResult = "MONKEY SOLD • SHARDS RETAINED • NEXT PLACEMENT HAS EMPTY SLOTS.";
				}
				else
				{
					lastResult = "SELLING IS LOCKED WHILE OR AFTER A HIDDEN EVOLUTION.";
				}
			}).Image).color = new Color(1f, 1f, 1f, 0f);
		}

		private void Roll(RollMode mode)
		{
			try
			{
				RollResult rollResult = ChaosMonkeyMod.Session.Roll(selectedSlot, mode, new Random());
				lastResult = $"NEW {rollResult.Item.Rarity.ToString().ToUpperInvariant()} • {rollResult.Item.DisplayName.ToUpperInvariant()} EQUIPPED";
				ChaosMonkeyMod.RefreshAppearanceAfterRoll(rollResult);
			}
			catch (InvalidOperationException ex)
			{
				lastResult = ex.Message.ToUpperInvariant();
			}
		}

		private static ModHelperText AddField(ModHelperWindow window, string name, float x, float y, float width, float height, string text, float fontSize)
		{
			//IL_0017: 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)
			((ModHelperComponent)window.content).AddImage(BoardInfo(name + "Panel", x, y, width, height), ModContent.GetSpriteReference<ChaosMonkeyMod>("ChaosTextField").guidRef);
			ModHelperText obj = ((ModHelperComponent)window.content).AddText(BoardInfo(name, x, y, width - 24f, height - 6f), text, BoardFont(fontSize), (TextAlignmentOptions)514);
			obj.EnableAutoSizing(BoardFont(fontSize), BoardFont(13f));
			return obj;
		}

		private static Info BoardInfo(string name, float x, float y, float width, float height)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			return new Info(name, x * 1.5f, y * 1.5f, width * 1.5f, height * 1.5f);
		}

		private static float BoardFont(float value)
		{
			return value * 1.5f;
		}

		private static string BuildShardText()
		{
			ChaosMonkeyMatchState match = ChaosMonkeyMod.Session.Match;
			if (match != null)
			{
				return $"SHARDS {match.Shards:N0}";
			}
			return "SHARDS —";
		}

		private static string BuildLuckText()
		{
			ChaosMonkeyMatchState match = ChaosMonkeyMod.Session.Match;
			if (match != null)
			{
				return $"LUCK ×{match.PurchasedLuck}";
			}
			return "LUCK ×—";
		}

		private static string BuildPityText()
		{
			ChaosMonkeyMatchState match = ChaosMonkeyMod.Session.Match;
			if (match == null)
			{
				return "LEGENDARY PITY —   •   MYTHIC PITY —   •   GODLY PITY —";
			}
			return $"LEGENDARY PITY {match.Pity.RollsSinceLegendaryOrHigher}/{150}   •   MYTHIC PITY {match.Pity.RollsSinceMythicOrHigher}/{500}   •   GODLY PITY {match.Pity.RollsSinceGodly}/{1000}";
		}

		private static string BuildEvolutionText()
		{
			EvolutionState evolutionState = ChaosMonkeyMod.Session.Match?.Evolution;
			string text = ((evolutionState == null || evolutionState.Kind == EvolutionKind.None) ? "EVOLUTION STATUS: HIDDEN" : (evolutionState.IsInProgress ? $"HIDDEN EVOLUTION: {evolutionState.RoundsCompleted}/{evolutionState.RoundsRequired} ROUNDS" : "HIDDEN EVOLUTION: COMPLETE"));
			SynergyDefinition synergyDefinition = ChaosMonkeyMod.Session.ActiveSynergies.FirstOrDefault((SynergyDefinition synergy) => synergy.IsFullSet);
			if ((object)synergyDefinition != null)
			{
				return text + " • " + synergyDefinition.DisplayName.ToUpperInvariant() + " ACTIVE";
			}
			return text;
		}

		private static string BuildPortraitAssetName()
		{
			EvolutionState evolutionState = ChaosMonkeyMod.Session.Match?.Evolution;
			if (evolutionState == null || !evolutionState.IsComplete)
			{
				return "ChaosMonkeyBaseUnarmed";
			}
			if (evolutionState.Kind != EvolutionKind.SecretAscension)
			{
				return "ChaosMonkeyGodlyEvolution";
			}
			return "ChaosMonkeySecretEvolution";
		}

		private static string BuildSellText()
		{
			ChaosMonkeyMatchState? match = ChaosMonkeyMod.Session.Match;
			if (match == null || !match.CanSell)
			{
				return "SELL LOCKED • HIDDEN EVOLUTION IN PROGRESS OR COMPLETE";
			}
			return "SELL CHAOS MONKEY • RETAIN UNUSED SHARDS • RESET GEAR";
		}

		private string BuildSlotText(EquipmentSlot slot)
		{
			ItemDefinition itemDefinition = ChaosMonkeyMod.Session.Match?.GetItem(slot);
			string text = ((slot == selectedSlot) ? "SELECTED" : "SELECT");
			return ChaosItemDetailsCatalog.SlotName(slot) + " • " + text + "\n" + (((object)itemDefinition == null) ? "EMPTY • ROLL TO DISCOVER" : (itemDefinition.Rarity.ToString().ToUpperInvariant() + " • " + itemDefinition.DisplayName.ToUpperInvariant()));
		}

		private string BuildDetailsTitle()
		{
			ItemDefinition itemDefinition = ChaosMonkeyMod.Session.Match?.GetItem(selectedSlot);
			if ((object)itemDefinition != null)
			{
				return itemDefinition.Rarity.ToString().ToUpperInvariant() + " • " + itemDefinition.DisplayName.ToUpperInvariant();
			}
			return ChaosItemDetailsCatalog.SlotName(selectedSlot) + " • EMPTY SLOT";
		}

		private ChaosItemDetails BuildDetails()
		{
			ItemDefinition itemDefinition = ChaosMonkeyMod.Session.Match?.GetItem(selectedSlot);
			if ((object)itemDefinition != null)
			{
				return ChaosItemDetailsCatalog.Get(itemDefinition);
			}
			return ChaosItemDetailsCatalog.Empty(selectedSlot);
		}

		private string BuildRollText(RollMode mode)
		{
			ChaosMonkeyMatchState match = ChaosMonkeyMod.Session.Match;
			if (match == null)
			{
				return "PREPARING…";
			}
			switch (mode)
			{
			case RollMode.Normal:
				return $"NORMAL ROLL\n{ChaosEconomy.GetRollCost(selectedSlot, RollMode.Normal)} SHARDS • {ChaosItemDetailsCatalog.SlotName(selectedSlot)}";
			case RollMode.Random:
				if (match.RandomRollUnlocked)
				{
					return $"RANDOM ROLL\n{90} SHARDS • RANDOM SLOT";
				}
				return $"RANDOM ROLL\nUNLOCK AT {match.RandomUnlockAtNormalRoll} NORMAL ROLLS";
			case RollMode.Special:
				return $"SPECIAL ROLL\n{ChaosEconomy.GetRollCost(selectedSlot, RollMode.Special)} SHARDS • MINIMUM ×32 LUCK";
			default:
				return string.Empty;
			}
		}
	}
	public sealed class ChaosMonkeyMod : BloonsTD6Mod
	{
		private static string? chaosMonkeyModelName;

		private static bool dashboardOpenRequested;

		private static bool luckOddsOpenRequested;

		internal static ChaosMonkeySession Session { get; } = new ChaosMonkeySession(ItemCatalog.CreateInitial(), new GachaEngine());

		internal static bool IsDeveloperModeAvailable => string.Equals(Environment.UserName, "Lauri", StringComparison.OrdinalIgnoreCase);

		public override void OnApplicationStart()
		{
			ModHelper.Msg<ChaosMonkeyMod>((object)"Chaos Monkey 1.0.0 loaded for BTD6 v56.3.");
		}

		public override void OnMatchStart()
		{
			ResetMapSession();
			ModHelper.Msg<ChaosMonkeyMod>((object)("Registered Chaos Monkey model: " + chaosMonkeyModelName + "."));
		}

		public override void OnRestart()
		{
			ResetMapSession();
		}

		private static void ResetMapSession()
		{
			Session.BeginMap(new Random());
			ChaosShardHud.Reset();
			ChaosMonkeyAppearance.Reset();
			dashboardOpenRequested = false;
			luckOddsOpenRequested = false;
			ChaosShardUpgradePanel.Dispose();
			chaosMonkeyModelName = ((Model)ModContent.GetTowerModel<ChaosMonkeyTower>(0, 0, 0)).name;
		}

		public override void OnRoundEnd()
		{
			if (Session.AdvanceRound())
			{
				ChaosMonkeyAppearance.RefreshAfterEvolution();
				ModHelper.Msg<ChaosMonkeyMod>((object)"A hidden Chaos Monkey evolution has completed.");
			}
		}

		public override void OnTowerGraphicsCreated(TowerModel towerModel, List<UnityDisplayNode> nodes)
		{
			if (IsChaosMonkeyModel((Model)(object)towerModel))
			{
				ChaosMonkeyAppearance.RegisterGraphics(nodes);
			}
		}

		public override void OnTowerCreated(Tower tower, Entity target, Model modelToUse)
		{
			if (IsChaosMonkeyModel(modelToUse))
			{
				if (!Session.IsPlacementAvailable)
				{
					ModHelper.Msg<ChaosMonkeyMod>((object)"Ignored an additional Chaos Monkey: one is allowed per map.");
					return;
				}
				Session.PlaceChaosMonkey();
				ChaosMonkeyAppearance.Attach(tower);
				ModHelper.Msg<ChaosMonkeyMod>((object)"Chaos Monkey placed.");
			}
		}

		public override void OnTowerSold(Tower tower, float amount)
		{
			if (IsActiveChaosMonkey(tower) && Session.TrySellChaosMonkey())
			{
				ChaosMonkeyAppearance.Reset();
				ModHelper.Msg<ChaosMonkeyMod>((object)"Chaos Monkey sold. It may be placed again with its remaining Shards, but an empty loadout.");
			}
		}

		public override void OnTowerSelected(Tower tower)
		{
			if (!IsActiveChaosMonkey(tower))
			{
				SetDefaultTowerPanelVisible(isVisible: true);
				return;
			}
			SetDefaultTowerPanelVisible(isVisible: true);
			dashboardOpenRequested = true;
			luckOddsOpenRequested = true;
			ChaosMonkeyAppearance.RefreshForSelection(tower);
			ChaosShardUpgradePanel.Show();
		}

		public override void OnTowerDeselected(Tower tower)
		{
			if (IsActiveChaosMonkey(tower))
			{
				ModHelperWindow[] array = ((ModWindow)ModContent.GetInstance<ChaosMonkeyDashboardWindow>()).OpenedWindows.ToArray();
				for (int i = 0; i < array.Length; i++)
				{
					array[i].Close();
				}
				array = ((ModWindow)ModContent.GetInstance<ChaosLuckOddsWindow>()).OpenedWindows.ToArray();
				for (int i = 0; i < array.Length; i++)
				{
					array[i].Close();
				}
				ChaosShardUpgradePanel.Hide();
			}
		}

		public override void OnUpdate()
		{
			ChaosShardHud.Refresh(Session);
			ChaosMonkeyAppearance.Tick();
			if (IsDeveloperModeAvailable && Input.GetKeyDown((KeyCode)289) && Session.IsChaosMonkeyPresent)
			{
				ChaosDeveloperWindow instance = ModContent.GetInstance<ChaosDeveloperWindow>();
				if (((ModWindow)instance).OpenedWindows.Count == 0)
				{
					((ModWindow)instance).Open();
				}
				else
				{
					ModHelperWindow[] array = ((ModWindow)instance).OpenedWindows.ToArray();
					for (int i = 0; i < array.Length; i++)
					{
						array[i].Close();
					}
				}
			}
			if (dashboardOpenRequested)
			{
				dashboardOpenRequested = false;
				ChaosMonkeyDashboardWindow instance2 = ModContent.GetInstance<ChaosMonkeyDashboardWindow>();
				if (((ModWindow)instance2).OpenedWindows.Count == 0)
				{
					((ModWindow)instance2).Open();
				}
			}
			if (luckOddsOpenRequested)
			{
				luckOddsOpenRequested = false;
				ChaosLuckOddsWindow instance3 = ModContent.GetInstance<ChaosLuckOddsWindow>();
				if (((ModWindow)instance3).OpenedWindows.Count == 0)
				{
					((ModWindow)instance3).Open();
				}
			}
			ChaosShardUpgradePanel.Refresh();
		}

		private static bool IsActiveChaosMonkey(Tower tower)
		{
			if (Session.IsChaosMonkeyPresent)
			{
				if (!IsChaosMonkeyModel((Model)(object)tower.towerModel))
				{
					return ChaosMonkeyAppearance.IsAttachedTo(tower);
				}
				return true;
			}
			return false;
		}

		private static void SetDefaultTowerPanelVisible(bool isVisible)
		{
			TowerSelectionMenu towerSelectionMenu = Instances.TowerSelectionMenu;
			if (towerSelectionMenu != null)
			{
				((Component)towerSelectionMenu).gameObject.SetActive(isVisible);
			}
		}

		private static bool IsChaosMonkeyModel(Model model)
		{
			string name = model.name;
			if (chaosMonkeyModelName == null || !name.StartsWith(chaosMonkeyModelName, StringComparison.Ordinal))
			{
				return name.Contains("ChaosMonkey", StringComparison.OrdinalIgnoreCase);
			}
			return true;
		}

		internal static void RefreshAppearanceAfterRoll(RollResult result)
		{
			ChaosMonkeyAppearance.RefreshAfterRoll(result);
		}

		internal static void EquipDeveloperItem(string itemId)
		{
			if (IsDeveloperModeAvailable)
			{
				Session.EquipDeveloperItem(itemId, new Random());
				ChaosMonkeyAppearance.RefreshAfterDeveloperLoadout();
			}
		}

		internal static bool TrySellActiveChaosMonkey()
		{
			ChaosMonkeyMatchState? match = Session.Match;
			if (match == null || !match.CanSell)
			{
				return false;
			}
			return ChaosMonkeyAppearance.TrySellActiveTower();
		}
	}
	public sealed class ChaosMonkeyTower : ModTower
	{
		public override TowerSet TowerSet => (TowerSet)4;

		public override string BaseTower => TowerType.DartMonkey;

		public override int Cost => 650;

		public override int TopPathUpgrades => 0;

		public override int MiddlePathUpgrades => 0;

		public override int BottomPathUpgrades => 0;

		public override int ShopTowerCount => 1;

		public override string Description => "A six-slot Chaos Gacha tower. Sell and re-place it before an unknown evolution begins; its remaining Shards stay, but its loadout resets.";

		public override void ModifyBaseTowerModel(TowerModel towerModel)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected O, but got Unknown
			towerModel.range = 45f;
			if (TowerModelBehaviorExt.GetBehavior<OverrideCamoDetectionModel>(towerModel) == null)
			{
				TowerModelBehaviorExt.AddBehavior<OverrideCamoDetectionModel>(towerModel, new OverrideCamoDetectionModel("ChaosMonkeyAlwaysDetectsCamo", true));
			}
			AttackModel behavior = TowerModelBehaviorExt.GetBehavior<AttackModel>(towerModel);
			behavior.range = 45f;
			((Il2CppArrayBase<WeaponModel>)(object)behavior.weapons)[0].Rate = 0.4f;
			FilterInvisibleModel behavior2 = AttackModelBehaviorExt.GetBehavior<FilterInvisibleModel>(behavior);
			if (behavior2 == null)
			{
				AttackModelBehaviorExt.AddBehavior<FilterInvisibleModel>(behavior, new FilterInvisibleModel("ChaosMonkeyCamoTargeting", true, false));
			}
			else
			{
				behavior2.isActive = true;
			}
			ProjectileModel projectile = ((Il2CppArrayBase<WeaponModel>)(object)behavior.weapons)[0].projectile;
			projectile.pierce = 5f;
			ProjectileModelExt.SetHitCamo(projectile, true);
			DamageModel behavior3 = ProjectileModelBehaviorExt.GetBehavior<DamageModel>(projectile);
			behavior3.damage = 4f;
			behavior3.immuneBloonProperties = (BloonProperties)0;
		}
	}
	internal static class ChaosShardHud
	{
		private const string ShardIconTexture = "ChaosShardIcon";

		private static ModHelperImage? shardIcon;

		private static ModHelperText? shardText;

		private static readonly MethodInfo? GetLeftHud = typeof(MainHudLeftAlignExt).GetMethod("get_instance", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);

		internal static void Reset()
		{
			object? obj = GetLeftHud?.Invoke(null, null);
			Component val = (Component)((obj is Component) ? obj : null);
			if (val != null)
			{
				RemoveExistingHud(val);
			}
			shardIcon = null;
			shardText = null;
		}

		internal static void Refresh(ChaosMonkeySession session)
		{
			//IL_0052: 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)
			if (session.Match == null)
			{
				return;
			}
			object? obj = GetLeftHud?.Invoke(null, null);
			Component val = (Component)((obj is Component) ? obj : null);
			if (val != null)
			{
				if (shardText == null)
				{
					RemoveExistingHud(val);
					shardIcon = GameObjectExt.AddImage(val.gameObject, new Info("ChaosShardHudIcon", 1100f, -65f, 185f, 185f), ModContent.GetSpriteReference<ChaosMonkeyMod>("ChaosShardIcon").guidRef);
					shardText = GameObjectExt.AddText(val.gameObject, new Info("ChaosShardHud", 1285f, -65f, 220f, 120f), string.Empty, 64f);
				}
				shardText.SetText(session.Match.Shards.ToString("N0"));
			}
		}

		private static void RemoveExistingHud(Component leftHud)
		{
			Transform[] array = ((IEnumerable<Transform>)leftHud.GetComponentsInChildren<Transform>(true)).Where(delegate(Transform transform)
			{
				string name = ((Object)transform).name;
				return (name == "ChaosShardHud" || name == "ChaosShardHudIcon") ? true : false;
			}).ToArray();
			for (int num = 0; num < array.Length; num++)
			{
				Object.Destroy((Object)(object)((Component)array[num]).gameObject);
			}
		}
	}
	internal static class ChaosShardUpgradePanel
	{
		private const string RootPrefix = "ChaosMonkeyNativeShard";

		private static readonly List<GameObject> uiObjects = new List<GameObject>();

		private static readonly List<GameObject> hiddenPathClosedLabels = new List<GameObject>();

		private static readonly List<TextMeshProUGUI> packTexts = new List<TextMeshProUGUI>();

		private static TextMeshProUGUI? shardsText;

		private static TextMeshProUGUI? statusText;

		private static string status = "REPEATABLE SHARD PURCHASES";

		private static bool showRequested;

		internal static void Show()
		{
			showRequested = true;
			TowerSelectionMenu towerSelectionMenu = Instances.TowerSelectionMenu;
			if (towerSelectionMenu == null)
			{
				return;
			}
			if (uiObjects.Count > 0 && BelongsToCurrentMenu(((Component)towerSelectionMenu).transform))
			{
				SetGeneratedObjectsActive(isActive: true);
				HidePathClosedLabels(((Component)towerSelectionMenu).transform);
				Refresh();
				return;
			}
			DisposeGeneratedObjects();
			Button componentInChildren = ((Component)towerSelectionMenu).GetComponentInChildren<Button>(true);
			TextMeshProUGUI componentInChildren2 = ((Component)towerSelectionMenu).GetComponentInChildren<TextMeshProUGUI>(true);
			Image componentInChildren3 = ((Component)towerSelectionMenu).GetComponentInChildren<Image>(true);
			if (componentInChildren == null || componentInChildren2 == null || componentInChildren3 == null)
			{
				return;
			}
			try
			{
				HidePathClosedLabels(((Component)towerSelectionMenu).transform);
				for (int i = 0; i < ChaosEconomy.ShardPacks.Count; i++)
				{
					int num = i % 2;
					int num2 = i / 2;
					AddPurchaseCard(((Component)towerSelectionMenu).transform, componentInChildren, componentInChildren2, componentInChildren3, ChaosEconomy.ShardPacks[i], (num == 0) ? 0.28f : 0.72f, 0.54f - (float)num2 * 0.19f);
				}
			}
			catch (Exception ex)
			{
				ModHelper.Error<ChaosMonkeyMod>((object)("Could not build native Chaos Shard panel: " + ex.Message));
				Hide();
			}
		}

		internal static void Refresh()
		{
			if (showRequested && uiObjects.Count == 0)
			{
				Show();
			}
			TextMeshProUGUI? obj = shardsText;
			if (obj != null)
			{
				((TMP_Text)obj).SetText(BuildShardText());
			}
			TextMeshProUGUI? obj2 = statusText;
			if (obj2 != null)
			{
				((TMP_Text)obj2).SetText(status);
			}
			for (int i = 0; i < packTexts.Count && i < ChaosEconomy.ShardPacks.Count; i++)
			{
				((TMP_Text)packTexts[i]).SetText(BuildPackText(ChaosEconomy.ShardPacks[i]));
			}
		}

		internal static void Hide()
		{
			showRequested = false;
			SetGeneratedObjectsActive(isActive: false);
			foreach (GameObject hiddenPathClosedLabel in hiddenPathClosedLabels)
			{
				if (hiddenPathClosedLabel != null)
				{
					hiddenPathClosedLabel.SetActive(true);
				}
			}
			hiddenPathClosedLabels.Clear();
		}

		internal static void Dispose()
		{
			showRequested = false;
			DisposeGeneratedObjects();
			foreach (GameObject hiddenPathClosedLabel in hiddenPathClosedLabels)
			{
				if (hiddenPathClosedLabel != null)
				{
					hiddenPathClosedLabel.SetActive(true);
				}
			}
			hiddenPathClosedLabels.Clear();
		}

		private static void DisposeGeneratedObjects()
		{
			foreach (GameObject item in uiObjects.Distinct())
			{
				if (item != null)
				{
					Object.Destroy((Object)(object)item);
				}
			}
			uiObjects.Clear();
			packTexts.Clear();
			shardsText = null;
			statusText = null;
			status = "REPEATABLE SHARD PURCHASES";
		}

		private static bool BelongsToCurrentMenu(Transform menu)
		{
			if (uiObjects.Count > 0)
			{
				return uiObjects.All((GameObject item) => item != null && item.transform.IsChildOf(menu));
			}
			return false;
		}

		private static void SetGeneratedObjectsActive(bool isActive)
		{
			foreach (GameObject uiObject in uiObjects)
			{
				if (uiObject != null)
				{
					uiObject.SetActive(isActive);
				}
			}
		}

		private static void AddPurchaseCard(Transform parent, Button buttonTemplate, TextMeshProUGUI textTemplate, Image imageTemplate, ShardPack pack, float x, float y)
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: 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_00f7: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(((Component)buttonTemplate).gameObject, parent);
			((Object)val).name = "ChaosMonkeyNativeShardCard" + pack.Id;
			uiObjects.Add(val);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(x - 0.2f, y - 0.065f);
			component.anchorMax = new Vector2(x + 0.2f, y + 0.065f);
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			Button component2 = val.GetComponent<Button>();
			((UnityEventBase)component2.onClick).RemoveAllListeners();
			((UnityEvent)component2.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
			{
				Purchase(pack);
			}));
			((Selectable)component2).targetGraphic = (Graphic)(object)val.GetComponent<Image>();
			((Selectable)component2).transition = (Transition)0;
			((Selectable)component2).interactable = true;
			Image component3 = val.GetComponent<Image>();
			if (component3 != null)
			{
				((Graphic)component3).color = new Color(1f, 1f, 1f, 0f);
			}
			foreach (TextMeshProUGUI componentsInChild in val.GetComponentsInChildren<TextMeshProUGUI>(true))
			{
				((Component)componentsInChild).gameObject.SetActive(false);
			}
			foreach (Image componentsInChild2 in val.GetComponentsInChildren<Image>(true))
			{
				if ((Object)(object)((Component)componentsInChild2).gameObject != (Object)(object)val)
				{
					((Component)componentsInChild2).gameObject.SetActive(false);
				}
			}
			AddCardBackground(val.transform, imageTemplate);
			AddShardIcon(val.transform, imageTemplate);
			AddNativeText(val.transform, textTemplate, "Label" + pack.Id, BuildPackText(pack), 0.5f, 0.82f, 28f, out TextMeshProUGUI output, 0.9f, 0.76f);
			packTexts.Add(output);
		}

		private static void AddCardBackground(Transform parent, Image template)
		{
			//IL_00a2: 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_00b8: 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_010e: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(((Component)template).gameObject, parent);
			((Object)val).name = "ChaosMonkeyNativeShardBackground";
			uiObjects.Add(val);
			foreach (TextMeshProUGUI componentsInChild in val.GetComponentsInChildren<TextMeshProUGUI>(true))
			{
				((Component)componentsInChild).gameObject.SetActive(false);
			}
			foreach (Image componentsInChild2 in val.GetComponentsInChildren<Image>(true))
			{
				if ((Object)(object)((Component)componentsInChild2).gameObject != (Object)(object)val)
				{
					((Component)componentsInChild2).gameObject.SetActive(false);
				}
			}
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			val.transform.SetAsFirstSibling();
			Image component2 = val.GetComponent<Image>();
			component2.sprite = ModContent.GetSprite<ChaosMonkeyMod>("ChaosTextField", 100f);
			component2.type = (Type)1;
			((Graphic)component2).color = new Color(0.18f, 0.045f, 0.34f, 1f);
			((Graphic)component2).raycastTarget = false;
		}

		private static void AddShardIcon(Transform parent, Image template)
		{
			//IL_00ac: 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_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: 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)
			GameObject val = Object.Instantiate<GameObject>(((Component)template).gameObject, parent);
			((Object)val).name = "ChaosMonkeyNativeShardIcon";
			uiObjects.Add(val);
			foreach (TextMeshProUGUI componentsInChild in val.GetComponentsInChildren<TextMeshProUGUI>(true))
			{
				((Component)componentsInChild).gameObject.SetActive(false);
			}
			foreach (Image componentsInChild2 in val.GetComponentsInChildren<Image>(true))
			{
				if ((Object)(object)((Component)componentsInChild2).gameObject != (Object)(object)val)
				{
					((Component)componentsInChild2).gameObject.SetActive(false);
				}
			}
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.07f, 0.24f);
			component.anchorMax = new Vector2(0.27f, 0.76f);
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			Image component2 = val.GetComponent<Image>();
			component2.sprite = ModContent.GetSprite<ChaosMonkeyMod>("ChaosShardIcon", 100f);
			component2.type = (Type)0;
			((Graphic)component2).color = Color.white;
			((Graphic)component2).raycastTarget = false;
		}

		private static void AddNativeText(Transform parent, TextMeshProUGUI template, string name, string value, float y, float height, float fontSize, out TextMeshProUGUI? output, float width = 0.9f, float centerX = 0.5f)
		{
			//IL_0046: 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_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: 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_00d2: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(((Component)template).gameObject, parent);
			((Object)val).name = "ChaosMonkeyNativeShard" + name;
			uiObjects.Add(val);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(centerX - width * 0.5f, y - height * 0.5f);
			component.anchorMax = new Vector2(centerX + width * 0.5f, y + height * 0.5f);
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			TextMeshProUGUI component2 = val.GetComponent<TextMeshProUGUI>();
			((Component)component2).gameObject.SetActive(true);
			((TMP_Text)component2).SetText(value);
			((TMP_Text)component2).fontSize = fontSize;
			((TMP_Text)component2).enableAutoSizing = false;
			((TMP_Text)component2).alignment = (TextAlignmentOptions)514;
			((Graphic)component2).color = Color.white;
			((TMP_Text)component2).fontStyle = (FontStyles)1;
			((TMP_Text)component2).outlineColor = Color32.op_Implicit(Color.black);
			((TMP_Text)component2).outlineWidth = 0.22f;
			output = component2;
		}

		private static void HidePathClosedLabels(Transform menu)
		{
			foreach (TextMeshProUGUI componentsInChild in ((Component)menu).GetComponentsInChildren<TextMeshProUGUI>(true))
			{
				if (!((TMP_Text)componentsInChild).text.Contains("PATH CLOSED", StringComparison.OrdinalIgnoreCase))
				{
					continue;
				}
				Transform val = ((TMP_Text)componentsInChild).transform;
				bool flag = false;
				while (val.parent != null && (Object)(object)val != (Object)(object)menu)
				{
					if (((Component)val).GetComponent<Button>() != null)
					{
						flag = true;
						break;
					}
					val = val.parent;
				}
				GameObject val2 = (flag ? ((Component)val).gameObject : ((Component)componentsInChild).gameObject);
				if (!hiddenPathClosedLabels.Contains(val2))
				{
					val2.SetActive(false);
					hiddenPathClosedLabels.Add(val2);
				}
			}
		}

		private static void Purchase(ShardPack pack)
		{
			try
			{
				InGame instance = InGame.instance;
				if (instance == null || !ChaosMonkeyMod.Session.IsChaosMonkeyPresent || ChaosMonkeyMod.Session.Match == null)
				{
					throw new InvalidOperationException("SELECT AN ACTIVE CHAOS MONKEY FIRST.");
				}
				if (InGameExt.GetCash(instance) < (double)pack.CashCost)
				{
					status = $"NOT ENOUGH CASH FOR {pack.Shards:N0} SHARDS.";
				}
				else
				{
					InGameExt.AddCash(instance, (double)(-pack.CashCost));
					ChaosMonkeyMod.Session.PurchaseShards(pack);
					status = $"+{pack.Shards:N0} SHARDS • BUY AGAIN ANY TIME";
				}
			}
			catch (InvalidOperationException ex)
			{
				status = ex.Message.ToUpperInvariant();
			}
		}

		private static string BuildShardText()
		{
			if (ChaosMonkeyMod.Session.Match != null)
			{
				return $"SHARDS {ChaosMonkeyMod.Session.Match.Shards:N0}";
			}
			return "SHARDS —";
		}

		private static string BuildPackText(ShardPack pack)
		{
			return $"{pack.Shards:N0} SHARDS\n${pack.CashCost:N0}";
		}
	}
	internal static class ChaosWeaponProjectileDisplays
	{
		internal static void Apply(string weaponId, ProjectileModel projectile)
		{
			if (weaponId == null)
			{
				return;
			}
			switch (weaponId.Length)
			{
			case 10:
				switch (weaponId[1])
				{
				case 'u':
					if (weaponId == "rusty-dart")
					{
						ProjectileModelExt.SetDisplay<ChaosProjectileRustyDartDisplay>(projectile);
					}
					break;
				case 'w':
					if (weaponId == "twin-darts")
					{
						ProjectileModelExt.SetDisplay<ChaosProjectileTwinDartsDisplay>(projectile);
					}
					break;
				case 'o':
					if (weaponId == "toy-cannon")
					{
						ProjectileModelExt.SetDisplay<ChaosProjectileToyCannonDisplay>(projectile);
					}
					break;
				}
				break;
			case 15:
				switch (weaponId[1])
				{
				case 'h':
					if (weaponId == "chaos-slingshot")
					{
						ProjectileModelExt.SetDisplay<ChaosProjectileChaosSlingshotDisplay>(projectile);
					}
					break;
				case 'e':
					if (weaponId == "pebble-launcher")
					{
						ProjectileModelExt.SetDisplay<ChaosProjectilePebbleLauncherDisplay>(projectile);
					}
					break;
				case 'p':
					if (weaponId == "spiked-launcher")
					{
						ProjectileModelExt.SetDisplay<ChaosProjectileSpikedLauncherDisplay>(projectile);
					}
					break;
				case 'o':
					if (weaponId == "poison-dart-gun")
					{
						ProjectileModelExt.SetDisplay<ChaosProjectilePoisonDartGunDisplay>(projectile);
					}
					break;
				case 'a':
					if (weaponId == "rapid-chaos-bow")
					{
						ProjectileModelExt.SetDisplay<ChaosProjectileRapidChaosBowDisplay>(projectile);
					}
					break;
				}
				break;
			case 13:
				switch (weaponId[3])
				{
				case 'a':
					if (weaponId == "scrap-blaster")
					{
						ProjectileModelExt.SetDisplay<ChaosProjectileScrapBlasterDisplay>(projectile);
					}
					break;
				case 'e':
					if (weaponId == "meteor-cannon")
					{
						ProjectileModelExt.SetDisplay<ChaosProjectileMeteorCannonDisplay>(projectile);
					}
					break;
				case 'l':
					if (weaponId == "reality-rifle")
					{
						ProjectileModelExt.SetDisplay<ChaosProjectileRealityRifleDisplay>(projectile);
					}
					break;
				case 'g':
					if (weaponId == "dragon-cannon")
					{
						ProjectileModelExt.SetDisplay<ChaosProjectileDragonCannonDisplay>(projectile);
					}
					break;
				case 'r':
					if (weaponId == "eternal-chaos")
					{
						ProjectileModelExt.SetDisplay<ChaosProjectileEternalChaosDisplay>(projectile);
					}
					break;
				case 'n':
					if (weaponId == "event-horizon")
					{
						ProjectileModelExt.SetDisplay<ChaosProjectileEventHorizonDisplay>(projectile);
					}
					break;
				}
				break;
			case 12:
				switch (weaponId[0])
				{
				case 'c':
					if (weaponId == "chaos-needle")
					{
						ProjectileModelExt.SetDisplay<ChaosProjectileChaosNeedleDisplay>(projectile);
					}
					break;
				case 'p':
					if (weaponId == "plasma-rifle")
					{
						ProjectileModelExt.SetDisplay<ChaosProjectilePlasmaRifleDisplay>(projectile);
					}
					break;
				case 'v':
					if (weaponId == "void-blaster")
					{
						ProjectileModelExt.SetDisplay<ChaosProjectileVoidBlasterDisplay>(projectile);
					}
					break;
				case 't':
					if (weaponId == "time-breaker")
					{
						ProjectileModelExt.SetDisplay<ChaosProjectileTimeBreakerDisplay>(projectile);
					}
					break;
				}
				break;
			case 11:
				switch (weaponId[0])
				{
				case 'b':
					if (weaponId == "broken-wand")
					{
						ProjectileModelExt.SetDisplay<ChaosProjectileBrokenWandDisplay>(projectile);
					}
					break;
				case 'm':
					if (weaponId == "mini-cannon")
					{
						ProjectileModelExt.SetDisplay<ChaosProjectileMiniCannonDisplay>(projectile);
					}
					break;
				case 's':
					if (weaponId == "soul-reaper")
					{
						ProjectileModelExt.SetDisplay<ChaosProjectileSoulReaperDisplay>(projectile);
					}
					break;
				case 'n':
					if (weaponId == "null-weapon")
					{
						ProjectileModelExt.SetDisplay<ChaosProjectileNullWeaponDisplay>(projectile);
					}
					break;
				}
				break;
			case 14:
				switch (weaponId[2])
				{
				case 'a':
					if (weaponId == "gravity-cannon")
					{
						ProjectileModelExt.SetDisplay<ChaosProjectileGravityCannonDisplay>(projectile);
					}
					break;
				case 'o':
					if (weaponId == "frost-launcher")
					{
						ProjectileModelExt.SetDisplay<ChaosProjectileFrostLauncherDisplay>(projectile);
					}
					break;
				case 'i':
					if (weaponId == "void-destroyer")
					{
						ProjectileModelExt.SetDisplay<ChaosProjectileVoidDestroyerDisplay>(projectile);
					}
					break;
				case 'n':
					if (weaponId == "genesis-weapon")
					{
						ProjectileModelExt.SetDisplay<ChaosProjectileGenesisWeaponDisplay>(projectile);
					}
					break;
				}
				break;
			case 19:
				switch (weaponId[0])
				{
				case 'b':
					if (weaponId == "black-hole-launcher")
					{
						ProjectileModelExt.SetDisplay<ChaosProjectileBlackHoleLauncherDisplay>(projectile);
					}
					break;
				case 't':
					if (weaponId == "the-unwritten-blade")
					{
						ProjectileModelExt.SetDisplay<ChaosProjectileTheUnwrittenBladeDisplay>(projectile);
					}
					break;
				}
				break;
			case 20:
				if (weaponId == "double-chaos-blaster")
				{
					ProjectileModelExt.SetDisplay<ChaosProjectileDoubleChaosBlasterDisplay>(projectile);
				}
				break;
			case 21:
				if (weaponId == "chain-lightning-staff")
				{
					ProjectileModelExt.SetDisplay<ChaosProjectileChainLightningStaffDisplay>(projectile);
				}
				break;
			case 17:
				if (weaponId == "chaos-accelerator")
				{
					ProjectileModelExt.SetDisplay<ChaosProjectileChaosAcceleratorDisplay>(projectile);
				}
				break;
			case 16:
				if (weaponId == "judgement-cannon")
				{
					ProjectileModelExt.SetDisplay<ChaosProjectileJudgementCannonDisplay>(projectile);
				}
				break;
			case 18:
				break;
			}
		}
	}
	public abstract class ChaosWeaponProjectileDisplay : ModDisplay
	{
		public override string BaseDisplay => "9dccc16d26c1c8a45b129e2a8cbd17ba";

		public override DisplayCategory DisplayCategory => (DisplayCategory)16;

		protected abstract string TextureName { get; }

		protected virtual float ProjectileScale => 0.115f;

		public override float Scale => ProjectileScale * 8f;

		public override void ModifyDisplayNode(UnityDisplayNode node)
		{
			((ModDisplay)this).Set2DTexture(node, TextureName);
		}
	}
	public sealed class ChaosProjectileRustyDartDisplay : ChaosWeaponProjectileDisplay
	{
		protected override string TextureName => "ChaosProjectileRustyDart";

		protected override float ProjectileScale => 0.095f;
	}
	public sealed class ChaosProjectileChaosSlingshotDisplay : ChaosWeaponProjectileDisplay
	{
		protected override string TextureName => "ChaosProjectileChaosSlingshot";
	}
	public sealed class ChaosProjectileTwinDartsDisplay : ChaosWeaponProjectileDisplay
	{
		protected override string TextureName => "ChaosProjectileTwinDarts";

		protected override float ProjectileScale => 0.11f;
	}
	public sealed class ChaosProjectileScrapBlasterDisplay : ChaosWeaponProjectileDisplay
	{
		protected override string TextureName => "ChaosProjectileScrapBlaster";
	}
	public sealed class ChaosProjectileChaosNeedleDisplay : ChaosWeaponProjectileDisplay
	{
		protected override string TextureName => "ChaosProjectileChaosNeedle";

		protected override float ProjectileScale => 0.09f;
	}
	public sealed class ChaosProjectilePebbleLauncherDisplay : ChaosWeaponProjectileDisplay
	{
		protected override string TextureName => "ChaosProjectilePebbleLauncher";
	}
	public sealed class ChaosProjectileBrokenWandDisplay : ChaosWeaponProjectileDisplay
	{
		protected override string TextureName => "ChaosProjectileBrokenWand";

		protected override float ProjectileScale => 0.125f;
	}
	public sealed class ChaosProjectileToyCannonDisplay : ChaosWeaponProjectileDisplay
	{
		protected override string TextureName => "ChaosProjectileToyCannon";

		protected override float ProjectileScale => 0.105f;
	}
	public sealed class ChaosProjectileDoubleChaosBlasterDisplay : ChaosWeaponProjectileDisplay
	{
		protected override string TextureName => "ChaosProjectileDoubleChaosBlaster";

		protected override float ProjectileScale => 0.13f;
	}
	public sealed class ChaosProjectileSpikedLauncherDisplay : ChaosWeaponProjectileDisplay
	{
		protected override string TextureName => "ChaosProjectileSpikedLauncher";
	}
	public sealed class ChaosProjectileMiniCannonDisplay : ChaosWeaponProjectileDisplay
	{
		protected override string TextureName => "ChaosProjectileMiniCannon";

		protected override float ProjectileScale => 0.125f;
	}
	public sealed class ChaosProjectilePoisonDartGunDisplay : ChaosWeaponProjectileDisplay
	{
		protected override string TextureName => "ChaosProjectilePoisonDartGun";

		protected override float ProjectileScale => 0.11f;
	}
	public sealed class ChaosProjectileRapidChaosBowDisplay : ChaosWeaponProjectileDisplay
	{
		protected override string TextureName => "ChaosProjectileRapidChaosBow";

		protected override float ProjectileScale => 0.12f;
	}
	public sealed class ChaosProjectilePlasmaRifleDisplay : ChaosWeaponProjectileDisplay
	{
		protected override string TextureName => "ChaosProjectilePlasmaRifle";

		protected override float ProjectileScale => 0.13f;
	}
	public sealed class ChaosProjectileGravityCannonDisplay : ChaosWeaponProjectileDisplay
	{
		protected override string TextureName => "ChaosProjectileGravityCannon";

		protected override float ProjectileScale => 0.13f;
	}
	public sealed class ChaosProjectileChainLightningStaffDisplay : ChaosWeaponProjectileDisplay
	{
		protected override string TextureName => "ChaosProjectileChainLightningStaff";

		protected override float ProjectileScale => 0.135f;
	}
	public sealed class ChaosProjectileFrostLauncherDisplay : ChaosWeaponProjectileDisplay
	{
		protected override string TextureName => "ChaosProjectileFrostLauncher";

		protected override float ProjectileScale => 0.13f;
	}
	public sealed class ChaosProjectileMeteorCannonDisplay : ChaosWeaponProjectileDisplay
	{
		protected override string TextureName => "ChaosProjectileMeteorCannon";

		protected override float ProjectileScale => 0.14f;
	}
	public sealed class ChaosProjectileVoidBlasterDisplay : ChaosWeaponProjectileDisplay
	{
		protected override string TextureName => "ChaosProjectileVoidBlaster";

		protected override float ProjectileScale => 0.13f;
	}
	public sealed class ChaosProjectileSoulReaperDisplay : ChaosWeaponProjectileDisplay
	{
		protected override string TextureName => "ChaosProjectileSoulReaper";

		protected override float ProjectileScale => 0.145f;
	}
	public sealed class ChaosProjectileBlackHoleLauncherDisplay : ChaosWeaponProjectileDisplay
	{
		protected override string TextureName => "ChaosProjectileBlackHoleLauncher";

		protected override float ProjectileScale => 0.14f;
	}
	public sealed class ChaosProjectileChaosAcceleratorDisplay : ChaosWeaponProjectileDisplay
	{
		protected override string TextureName => "ChaosProjectileChaosAccelerator";

		protected override float ProjectileScale => 0.15f;
	}
	public sealed class ChaosProjectileRealityRifleDisplay : ChaosWeaponProjectileDisplay
	{
		protected override string TextureName => "ChaosProjectileRealityRifle";

		protected override float ProjectileScale => 0.14f;
	}
	public sealed class ChaosProjectileDragonCannonDisplay : ChaosWeaponProjectileDisplay
	{
		protected override string TextureName => "ChaosProjectileDragonCannon";

		protected override float ProjectileScale => 0.15f;
	}
	public sealed class ChaosProjectileTimeBreakerDisplay : ChaosWeaponProjectileDisplay
	{
		protected override string TextureName => "ChaosProjectileTimeBreaker";

		protected override float ProjectileScale => 0.14f;
	}
	public sealed class ChaosProjectileVoidDestroyerDisplay : ChaosWeaponProjectileDisplay
	{
		protected override string TextureName => "ChaosProjectileVoidDestroyer";

		protected override float ProjectileScale => 0.15f;
	}
	public sealed class ChaosProjectileJudgementCannonDisplay : ChaosWeaponProjectileDisplay
	{
		protected override string TextureName => "ChaosProjectileJudgementCannon";

		protected override float ProjectileScale => 0.14f;
	}
	public sealed class ChaosProjectileEternalChaosDisplay : ChaosWeaponProjectileDisplay
	{
		protected override string TextureName => "ChaosProjectileEternalChaos";

		protected override float ProjectileScale => 0.15f;
	}
	public sealed class ChaosProjectileGenesisWeaponDisplay : ChaosWeaponProjectileDisplay
	{
		protected override string TextureName => "ChaosProjectileGenesisWeapon";

		protected override float ProjectileScale => 0.15f;
	}
	public sealed class ChaosProjectileTheUnwrittenBladeDisplay : ChaosWeaponProjectileDisplay
	{
		protected override string TextureName => "ChaosProjectileTheUnwrittenBlade";

		protected override float ProjectileScale => 0.16f;
	}
	public sealed class ChaosProjectileEventHorizonDisplay : ChaosWeaponProjectileDisplay
	{
		protected override string TextureName => "ChaosProjectileEventHorizon";

		protected override float ProjectileScale => 0.17f;
	}
	public sealed class ChaosProjectileNullWeaponDisplay : ChaosWeaponProjectileDisplay
	{
		protected override string TextureName => "ChaosProjectileNullWeapon";

		protected override float ProjectileScale => 0.13f;
	}
	public static class ModHelperData
	{
		public const string WorksOnVersion = "56.3";

		public const string Version = "1.0.0";

		public const string Name = "Chaos Monkey";

		public const string Description = "Chaos Monkey is a single-player six-slot Gacha tower. Place one Monkey per map, choose Weapon, Ammo, Body, Head, Trait, or Ability, and spend Chaos Shards to discover gear with distinct combat effects. Purchase Shards with cash, increase Luck up to x2048, and use Pity protection while chasing powerful rarities. Normal, Random, and Special Rolls create unique loadouts, unlock synergies, and may reveal hidden Evolution paths. Completed Evolutions gain global range and a complete visual transformation. The tower detects Camo by default and every weapon can damage Lead Bloons. Co-op is not supported.";

		public const string Author = "Lauri";
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	internal sealed class IsExternalInit
	{
	}
}
namespace ChaosMonkey.Core
{
	public sealed class ChaosMonkeyService
	{
		private readonly ItemCatalog catalog;

		private readonly GachaEngine gacha;

		public ChaosMonkeyService(ItemCatalog catalog, GachaEngine gacha)
		{
			this.catalog = catalog;
			this.gacha = gacha;
		}

		public RollResult Roll(ChaosMonkeyMatchState state, EquipmentSlot? selectedSlot, RollMode mode, Random random)
		{
			if (state == null)
			{
				throw new ArgumentNullException("state");
			}
			if (random == null)
			{
				throw new ArgumentNullException("random");
			}
			EquipmentSlot slot = ResolveSlot(state, selectedSlot, mode, random);
			int rollCost = ChaosEconomy.GetRollCost(slot, mode);
			if (!state.TrySpendShards(rollCost))
			{
				throw new InvalidOperationException("Not enough Chaos Shards.");
			}
			int luckMultiplier = ResolveLuck(state, mode, random);
			(Rarity, bool, bool) tuple = gacha.Roll(state.Pity, luckMultiplier, random);
			ItemDefinition item = catalog.Pick(slot, tuple.Item1, random);
			state.Equip(slot, item, mode);
			return new RollResult(mode, slot, luckMultiplier, item, tuple.Item2, tuple.Item3);
		}

		private static EquipmentSlot ResolveSlot(ChaosMonkeyMatchState state, EquipmentSlot? selectedSlot, RollMode mode, Random random)
		{
			if (mode != RollMode.Random)
			{
				if (!selectedSlot.HasValue)
				{
					throw new ArgumentException("Choose an equipment slot.", "selectedSlot");
				}
				return selectedSlot.Value;
			}
			if (!state.RandomRollUnlocked)
			{
				throw new InvalidOperationException("Random Roll is not unlocked yet.");
			}
			EquipmentSlot[] array = DomainValues.EquipmentSlots.Where((EquipmentSlot slot) => !state.IsSlotLocked(slot)).ToArray();
			if (array.Length == 0)
			{
				throw new InvalidOperationException("Every equipment slot is locked.");
			}
			return array[random.Next(array.Length)];
		}

		private static int ResolveLuck(ChaosMonkeyMatchState state, RollMode mode, Random random)
		{
			return mode switch
			{
				RollMode.Normal => state.PurchasedLuck, 
				RollMode.Random => ChaosEconomy.RandomRollLuck[random.Next(ChaosEconomy.RandomRollLuck.Count)], 
				RollMode.Special => Math.Max(state.PurchasedLuck, 32), 
				_ => throw new ArgumentOutOfRangeException("mode"), 
			};
		}
	}
	public sealed class ChaosMonkeySession
	{
		private readonly ItemCatalog catalog;

		private readonly ChaosMonkeyService service;

		private readonly SynergyResolver synergyResolver;

		private bool evolutionCompletionRecorded;

		public ProfileProgress Profile { get; }

		public ChaosMonkeyMatchState? Match { get; private set; }

		public bool HasPlacedChaosMonkey { get; private set; }

		public bool IsChaosMonkeyPresent { get; private set; }

		public bool IsPlacementAvailable
		{
			get
			{
				if (Match != null)
				{
					return !IsChaosMonkeyPresent;
				}
				return false;
			}
		}

		public IReadOnlyList<SynergyDefinition> ActiveSynergies
		{
			get
			{
				if (Match != null)
				{
					return synergyResolver.Resolve(Match.Equipment);
				}
				return Array.Empty<SynergyDefinition>();
			}
		}

		public ChaosMonkeySession(ItemCatalog catalog, GachaEngine gacha, ProfileProgress? profile = null, SynergyResolver? synergyResolver = null)
		{
			this.catalog = catalog ?? throw new ArgumentNullException("catalog");
			service = new ChaosMonkeyService(catalog, gacha ?? throw new ArgumentNullException("gacha"));
			Profile = profile ?? new ProfileProgress();
			this.synergyResolver = synergyResolver ?? new SynergyResolver();
		}

		public IReadOnlyList<ItemDefinition> GetDeveloperItems(EquipmentSlot slot)
		{
			return (from item in catalog.All()
				where item.Slot == slot
				select item).ToArray();
		}

		public void BeginMap(Random random)
		{
			Match = new ChaosMonkeyMatchState(random ?? throw new ArgumentNullException("random"));
			HasPlacedChaosMonkey = false;
			IsChaosMonkeyPresent = false;
			evolutionCompletionRecorded = false;
		}

		public void RestoreMap(ChaosMonkeySessionSnapshot snapshot)
		{
			if ((object)snapshot == null)
			{
				throw new ArgumentNullException("snapshot");
			}
			Match = (((object)snapshot.Match == null) ? null : ChaosMonkeyMatchState.FromSnapshot(snapshot.Match, catalog));
			HasPlacedChaosMonkey = snapshot.HasPlacedChaosMonkey;
			IsChaosMonkeyPresent = snapshot.IsChaosMonkeyPresent;
			evolutionCompletionRecorded = snapshot.EvolutionCompletionRecorded;
			if (IsChaosMonkeyPresent && (!HasPlacedChaosMonkey || Match == null))
			{
				throw new InvalidOperationException("The saved Chaos Monkey state is inconsistent.");
			}
		}

		public void PlaceChaosMonkey()
		{
			RequireMap();
			if (IsChaosMonkeyPresent)
			{
				throw new InvalidOperationException("Only one Chaos Monkey may be placed on a map.");
			}
			HasPlacedChaosMonkey = true;
			IsChaosMonkeyPresent = true;
			Profile.RecordPlacement();
		}

		public bool TrySellChaosMonkey(Random? random = null)
		{
			RequireActiveMonkey();
			if (!Match.CanSell)
			{
				return false;
			}
			int shards = Match.Shards;
			Match = new ChaosMonkeyMatchState(random ?? new Random(), shards);
			IsChaosMonkeyPresent = false;
			return true;
		}

		public void AddShards(int amount)
		{
			RequireActiveMonkey();
			Match.AddShards(amount);
		}

		public void PurchaseShards(ShardPack pack)
		{
			RequireActiveMonkey();
			if (!ChaosEconomy.ShardPacks.Contains(pack))
			{
				throw new InvalidOperationException("Unknown Chaos Shard pack.");
			}
			Match.AddShards(pack.Shards);
		}

		public void PurchaseLuck(int multiplier)
		{
			RequireActiveMonkey();
			Match.PurchaseLuck(multiplier);
		}

		public void EquipDeveloperItem(string itemId, Random random)
		{
			RequireActiveMonkey();
			if (string.IsNullOrWhiteSpace(itemId))
			{
				throw new ArgumentException("An item id is required.", "itemId");
			}
			Random random2 = random ?? throw new ArgumentNullException("random");
			ChaosMonkeyMatchState match = Match;
			match.EquipDeveloper(catalog.Find(itemId));
			if (match.Evolution.Kind == EvolutionKind.None && match.GetAvailableEvolution() != EvolutionKind.None)
			{
				match.StartEvolution(random2);
			}
		}

		public RollResult Roll(EquipmentSlot? selectedSlot, RollMode mode, Random random)
		{
			RequireActiveMonkey();
			Random random2 = random ?? throw new ArgumentNullException("random");
			ChaosMonkeyMatchState match = Match;
			RollResult result = service.Roll(match, selectedSlot, mode, random2);
			Profile.RecordRoll(result);
			Profile.RecordSynergies(ActiveSynergies);
			if (match.Evolution.Kind == EvolutionKind.None && match.GetAvailableEvolution() != EvolutionKind.None)
			{
				match.StartEvolution(random2);
			}
			return result;
		}

		public void StartEvolution(Random random)
		{
			RequireActiveMonkey();
			Match.StartEvolution(random ?? throw new ArgumentNullException("random"));
		}

		public bool AdvanceRound()
		{
			if (!IsChaosMonkeyPresent || Match == null)
			{
				return false;
			}
			bool num = Match.Evolution.AdvanceRound();
			if (num && !evolutionCompletionRecorded && !Match.IsDeveloperLoadout)
			{
				Profile.RecordEvolution(Match.Evolution.Kind);
				evolutionCompletionRecorded = true;
			}
			return num;
		}

		public ChaosMonkeySessionSnapshot ToSnapshot()
		{
			return new ChaosMonkeySessionSnapshot(Match?.ToSnapshot(), HasPlacedChaosMonkey, IsChaosMonkeyPresent, evolutionCompletionRecorded);
		}

		private void RequireMap()
		{
			if (Match == null)
			{
				throw new InvalidOperationException("Start a map before using Chaos Monkey systems.");
			}
		}

		private void RequireActiveMonkey()
		{
			RequireMap();
			if (!IsChaosMonkeyPresent)
			{
				throw new InvalidOperationException("Place the Chaos Monkey first.");
			}
		}
	}
	public sealed record ChaosMonkeySessionSnapshot(ChaosMonkeyMatchSnapshot? Match, bool HasPlacedChaosMonkey, bool IsChaosMonkeyPresent, bool EvolutionCompletionRecorded);
	public sealed record ChaosCombatStats(float Damage, float Pierce, float AttackCooldown, float Range, int EquippedItemCount, int ActiveSynergyCount);
	public static class ChaosCombatBalance
	{
		private readonly record struct RarityStats(float Damage, float Pierce, float AttackSpeed);

		private readonly record struct SlotStats(float Damage, float Pierce, float AttackSpeed, float Range);

		private const float BaseDamage = 4f;

		private const float BasePierce = 5f;

		private const float BaseCooldown = 0.4f;

		private const float BaseRange = 45f;

		public const float GlobalEvolutionRange = 100000f;

		public static ChaosCombatStats Calculate(IReadOnlyDictionary<EquipmentSlot, ItemDefinition?> equipment, IReadOnlyCollection<SynergyDefinition> activeSynergies, EvolutionState? evolution = null)
		{
			if (equipment == null)
			{
				throw new ArgumentNullException("equipment");
			}
			if (activeSynergies == null)
			{
				throw new ArgumentNullException("activeSynergies");
			}
			float damage = 4f;
			float pierce = 5f;
			float attackSpeed = 0f;
			float range = 45f;
			int num = 0;
			EquipmentSlot[] equipmentSlots = DomainValues.EquipmentSlots;
			foreach (EquipmentSlot key in equipmentSlots)
			{
				if (equipment.TryGetValue(key, out ItemDefinition value) && (object)value != null)
				{
					num++;
					RarityStats rarityStats = RarityContribution(value.Rarity);
					SlotStats slotStats = SlotWeight(value.Slot);
					float num2 = 1f + (float)value.Tags.Count * 0.08f;
					damage += rarityStats.Damage * slotStats.Damage * num2;
					pierce += rarityStats.Pierce * slotStats.Pierce * num2;
					attackSpeed += rarityStats.AttackSpeed * slotStats.AttackSpeed + (float)value.Tags.Count * 0.035f;
					range += slotStats.Range;
					ApplyNamedItemBonus(value, ref damage, ref pierce, ref attackSpeed, ref range);
				}
			}
			foreach (SynergyDefinition activeSynergy in activeSynergies)
			{
				if (activeSynergy.IsFullSet && activeSynergy.IsSecret)
				{
					damage *= 3f;
					pierce *= 3f;
					attackSpeed += 5f;
				}
				else if (activeSynergy.IsFullSet && activeSynergy.IsGodly)
				{
					damage *= 2.2f;
					pierce *= 2f;
					attackSpeed += 3f;
				}
				else if (activeSynergy.IsSecret)
				{
					damage *= 1.6f;
					pierce *= 1.45f;
					attackSpeed += 1f;
				}
				else if (activeSynergy.IsGodly)
				{
					damage *= 1.35f;
					pierce *= 1.25f;
					attackSpeed += 0.6f;
				}
				else
				{
					damage *= 1.18f;
					pierce *= 1.12f;
					attackSpeed += 0.2f;
				}
			}
			if (evolution != null && evolution.IsComplete)
			{
				if (evolution.Kind == EvolutionKind.SecretAscension)
				{
					damage *= 7f;
					pierce *= 6f;
					attackSpeed += 10f;
					range = 100000f;
				}
				else if (evolution.Kind == EvolutionKind.ChaosAscendant)
				{
					damage *= 3.5f;
					pierce *= 3f;
					attackSpeed += 6f;
					range = 100000f;
				}
			}
			return new ChaosCombatStats(MathF.Round(MathF.Max(1f, damage), 1), MathF.Round(MathF.Max(1f, pierce), 1), MathF.Round(Math.Clamp(0.4f / (1f + attackSpeed), 0.025f, 0.4f), 3), MathF.Round(Math.Clamp(range, 45f, 100000f), 1), num, activeSynergies.Count);
		}

		private static void ApplyNamedItemBonus(ItemDefinition item, ref float damage, ref float pierce, ref float attackSpeed, ref float range)
		{
			string id = item.Id;
			if (id.Contains("rapid", StringComparison.Ordinal) || id.Contains("needle", StringComparison.Ordinal))
			{
				attackSpeed += 0.45f;
			}
			if (id.Contains("cannon", StringComparison.Ordinal) || id.Contains("launcher", StringComparison.Ordinal))
			{
				damage *= 1.14f;
				pierce *= 1.1f;
			}
			if (id.Contains("piercing", StringComparison.Ordinal) || id.Contains("plasma", StringComparison.Ordinal))
			{
				pierce *= 1.18f;
			}
			if (item.Tags.Contains("Moab"))
			{
				damage *= 1.2f;
			}
			if (item.Tags.Contains("Chaos"))
			{
				damage *= 1.08f;
				pierce *= 1.08f;
			}
			if (item.Tags.Contains("Reality") || item.Tags.Contains("Null"))
			{
				damage *= 1.12f;
				pierce *= 1.12f;
			}
			if (item.Tags.Contains("Time") || item.Tags.Contains("Frost"))
			{
				attackSpeed += 0.18f;
			}
			if (item.Tags.Contains("Hunter") || item.Tags.Contains("Observer"))
			{
				range += 8f;
			}
		}

		private static RarityStats RarityContribution(Rarity rarity)
		{
			return rarity switch
			{
				Rarity.Common => new RarityStats(4f, 6f, 0.1f), 
				Rarity.Uncommon => new RarityStats(10f, 15f, 0.2f), 
				Rarity.Rare => new RarityStats(25f, 35f, 0.35f), 
				Rarity.Epic => new RarityStats(60f, 85f, 0.55f), 
				Rarity.Legendary => new RarityStats(145f, 190f, 0.75f), 
				Rarity.Mythic => new RarityStats(330f, 440f, 1.1f), 
				Rarity.Godly => new RarityStats(750f, 1000f, 1.5f), 
				Rarity.Secret => new RarityStats(1500f, 2000f, 2.25f), 
				_ => throw new ArgumentOutOfRangeException("rarity"), 
			};
		}

		private static SlotStats SlotWeight(EquipmentSlot slot)
		{
			return slot switch
			{
				EquipmentSlot.Weapon => new SlotStats(1.6f, 1.25f, 1f, 8f), 
				EquipmentSlot.Ammo => new SlotStats(1f, 1.65f, 0.95f, 3f), 
				EquipmentSlot.Body => new SlotStats(0.95f, 0.9f, 0.9f, 5f), 
				EquipmentSlot.Head => new SlotStats(0.8f, 0.9f, 0.85f, 7f), 
				EquipmentSlot.Trait => new SlotStats(0.9f, 0.8f, 1.1f, 4f), 
				EquipmentSlot.Ability => new SlotStats(1.2f, 1.1f, 1.35f, 6f), 
				_ => throw new ArgumentOutOfRangeException("slot"), 
			};
		}
	}
	public enum EquipmentSlot
	{
		Weapon,
		Ammo,
		Body,
		Head,
		Trait,
		Ability
	}
	public enum Rarity
	{
		Common,
		Uncommon,
		Rare,
		Epic,
		Legendary,
		Mythic,
		Godly,
		Secret
	}
	public enum RollMode
	{
		Normal,
		Random,
		Special
	}
	public enum EvolutionKind
	{
		None,
		ChaosAscendant,
		SecretAscension
	}
	public sealed record ItemDefinition(string Id, string DisplayName, EquipmentSlot Slot, Rarity Rarity, IReadOnlyCollection<string> Tags, string Summary);
	public sealed record RollResult(RollMode Mode, EquipmentSlot Slot, int LuckMultiplier, ItemDefinition Item, bool WasPity, bool IsSecret);
	public sealed record ShardPack(string Id, int Shards, int CashCost);
	public static class ChaosEconomy
	{
		public const int StartingShards = 50;

		public const int NormalRollCost = 50;

		public const int RandomRollCost = 90;

		public static readonly IReadOnlyList<int> PurchasableLuck = new int[12]
		{
			1, 2, 4, 8, 16, 32, 64, 128, 256, 512,
			1024, 2048
		};

		public static readonly IReadOnlyDictionary<int, int> LuckCashCosts = new Dictionary<int, int>
		{
			[2] = 10000,
			[4] = 20000,
			[8] = 35000,
			[16] = 60000,
			[32] = 100000,
			[64] = 175000,
			[128] = 300000,
			[256] = 500000,
			[512] = 850000,
			[1024] = 1500000,
			[2048] = 2600000
		};

		public static readonly IReadOnlyList<int> RandomRollLuck = new int[12]
		{
			1, 2, 4, 8, 16, 32, 64, 128, 256, 512,
			1024, 2048
		};

		public static readonly IReadOnlyDictionary<EquipmentSlot, int> SlotRollCosts = new Dictionary<EquipmentSlot, int>
		{
			[EquipmentSlot.Weapon] = 50,
			[EquipmentSlot.Ammo] = 65,
			[EquipmentSlot.Body] = 85,
			[EquipmentSlot.Head] = 110,
			[EquipmentSlot.Trait] = 140,
			[EquipmentSlot.Ability] = 175
		};

		public static readonly IReadOnlyList<ShardPack> ShardPacks = new ShardPack[6]
		{
			new ShardPack("small", 50, 250),
			new ShardPack("medium", 250, 1000),
			new ShardPack("large", 500, 1750),
			new ShardPack("mega", 1000, 3000),
			new ShardPack("ultra", 2500, 6500),
			new ShardPack("apex", 5000, 11500)
		};

		public static int GetRollCost(EquipmentSlot slot, RollMode mode)
		{
			return mode switch
			{
				RollMode.Normal => SlotRollCosts[slot], 
				RollMode.Random => 90, 
				RollMode.Special => SlotRollCosts[slot] * 5, 
				_ => throw new ArgumentOutOfRangeException("mode"), 
			};
		}
	}
	internal static class DomainValues
	{
		public static readonly EquipmentSlot[] EquipmentSlots = (EquipmentSlot[])Enum.GetValues(typeof(EquipmentSlot));

		public static readonly Rarity[] Rarities = (Rarity[])Enum.GetValues(typeof(Rarity));
	}
	public sealed class PityState
	{
		public const int LegendaryThreshold = 150;

		public const int MythicThreshold = 500;

		public const int GodlyThreshold = 1000;

		public int RollsSinceLegendaryOrHigher { get; private set; }

		public int RollsSinceMythicOrHigher { get; private set; }

		public int RollsSinceGodly { get; private set; }

		public Rarity? GuaranteedRarity
		{
			get
			{
				if (RollsSinceGodly < 1000)
				{
					if (RollsSinceMythicOrHigher < 500)
					{
						if (RollsSinceLegendaryOrHigher < 150)
						{
							return null;
						}
						return Rarity.Legendary;
					}
					return Rarity.Mythic;
				}
				return Rarity.Godly;
			}
		}

		public void Register(Rarity rarity)
		{
			if (rarity == Rarity.Secret)
			{
				RollsSinceLegendaryOrHigher++;
				RollsSinceMythicOrHigher++;
				RollsSinceGodly++;
			}
			else
			{
				RollsSinceLegendaryOrHigher = ((rarity < Rarity.Legendary) ? (RollsSinceLegendaryOrHigher + 1) : 0);
				RollsSinceMythicOrHigher = ((rarity < Rarity.Mythic) ? (RollsSinceMythicOrHigher + 1) : 0);
				RollsSinceGodly = ((rarity != Rarity.Godly) ? (RollsSinceGodly + 1) : 0);
			}
		}

		public PitySnapshot ToSnapshot()
		{
			return new PitySnapshot(RollsSinceLegendaryOrHigher, RollsSinceMythicOrHigher, RollsSinceGodly);
		}

		internal void Load(PitySnapshot snapshot)
		{
			RollsSinceLegendaryOrHigher = snapshot.RollsSinceLegendaryOrHigher;
			RollsSinceMythicOrHigher = snapshot.RollsSinceMythicOrHigher;
			RollsSinceGodly = snapshot.RollsSinceGodly;
		}
	}
	public sealed record PitySnapshot(int RollsSinceLegendaryOrHigher, int RollsSinceMythicOrHigher, int RollsSinceGodly);
	public sealed class GachaEngine
	{
		public const int SecretDenominator = 5000;

		public const int SecretEchoDenominator = 25000;

		private const double LuckExponentPerTier = 0.25;

		private static readonly IReadOnlyDictionary<Rarity, double> BasePercent = new Dictionary<Rarity, double>
		{
			[Rarity.Common] = 70.0,
			[Rarity.Uncommon] = 22.0,
			[Rarity.Rare] = 6.5,
			[Rarity.Epic] = 1.35,
			[Rarity.Legendary] = 0.14,
			[Rarity.Mythic] = 0.009,
			[Rarity.Godly] = 0.001
		};

		public IReadOnlyDictionary<Rarity, double> GetDisplayedOdds(int luckMultiplier)
		{
			if (luckMultiplier < 1)
			{
				throw new ArgumentOutOfRangeException("luckMultiplier");
			}
			Dictionary<Rarity, double> dictionary = BasePercent.ToDictionary((KeyValuePair<Rarity, double> pair) => pair.Key, (KeyValuePair<Rarity, double> pair) => pair.Value * Math.Pow(luckMultiplier, (double)pair.Key * 0.25));
			double total = dictionary.Values.Sum();
			return dictionary.ToDictionary((KeyValuePair<Rarity, double> pair) => pair.Key, (KeyValuePair<Rarity, double> pair) => pair.Value / total * 100.0);
		}

		public (Rarity Rarity, bool WasPity, bool IsSecret) Roll(PityState pity, int luckMultiplier, Random random)
		{
			if (pity == null)
			{
				throw new ArgumentNullException("pity");
			}
			if (random == null)
			{
				throw new ArgumentNullException("random");
			}
			if (random.Next(5000) == 0)
			{
				pity.Register(Rarity.Secret);
				return (Rarity: Rarity.Secret, WasPity: false, IsSecret: true);
			}
			Rarity? guaranteedRarity = pity.GuaranteedRarity;
			Rarity rarity = guaranteedRarity ?? ChooseNormalRarity(luckMultiplier, random);
			if (random.Next(25000) == 0)
			{
				pity.Register(Rarity.Secret);
				return (Rarity: Rarity.Secret, WasPity: false, IsSecret: true);
			}
			pity.Register(rarity);
			return (Rarity: rarity, WasPity: guaranteedRarity.HasValue, IsSecret: false);
		}

		private Rarity ChooseNormalRarity(int luckMultiplier, Random random)
		{
			IReadOnlyDictionary<Rarity, double> displayedOdds = GetDisplayedOdds(luckMultiplier);
			double num = random.NextDouble() * 100.0;
			double num2 = 0.0;
			foreach (Rarity item in DomainValues.Rarities.Where((Rarity rarity) => rarity != Rarity.Secret))
			{
				num2 += displayedOdds[item];
				if (num < num2)
				{
					return item;
				}
			}
			return Rarity.Godly;
		}
	}
	public sealed class ItemCatalog
	{
		private readonly IReadOnlyList<ItemDefinition> items;

		private static readonly IReadOnlyDictionary<string, string> LegacyItemIds = new Dictionary<string, string>(StringComparer.Ordinal)
		{
			["observer"] = "observer-body",
			["broken-reality"] = "watching-eye",
			["unknown-weapon"] = "the-unwritten-blade",
			["unknown-trait"] = "fate-secret",
			["reality-erasure"] = "erase"
		};

		public ItemCatalog(IEnumerable<ItemDefinition> items)
		{
			this.items = items.ToArray();
			Validate(this.items);
		}

		public static ItemCatalog CreateInitial()
		{
			return new ItemCatalog(new ItemDefinition[166]
			{
				Item("rusty-dart", "Rusty Dart", EquipmentSlot.Weapon, Rarity.Common, "Basic rapid projectile."),
				Item("chaos-slingshot", "Chaos Slingshot", EquipmentSlot.Weapon, Rarity.Common, "Heavy chaotic pebbles with solid opening damage.", "Chaos"),
				Item("twin-darts", "Twin Darts", EquipmentSlot.Weapon, Rarity.Common, "Fires two darts per attack."),
				Item("scrap-blaster", "Scrap Blaster", EquipmentSlot.Weapon, Rarity.Common, "Low damage but broad scrap-shot pierce."),
				Item("chaos-needle", "Chaos Needle", EquipmentSlot.Weapon, Rarity.Common, "Extremely fast single-target needle fire."),
				Item("pebble-launcher", "Pebble Launcher", EquipmentSlot.Weapon, Rarity.Common, "Slow but hard-hitting stone projectiles."),
				Item("broken-wand", "Broken Wand", EquipmentSlot.Weapon, Rarity.Common, "Sometimes creates a bonus magic hit.", "Chaos"),
				Item("toy-cannon", "Toy Cannon", EquipmentSlot.Weapon, Rarity.Common, "Very slow toy shells with surprising impact damage."),
				Item("double-chaos-blaster", "Double Chaos Blaster", EquipmentSlot.Weapon, Rarity.Uncommon, "Fires two chaotic bolts per attack.", "Chaos"),
				Item("spiked-launcher", "Spiked Launcher", EquipmentSlot.Weapon, Rarity.Uncommon, "Spiked shots deal high damage and pierce."),
				Item("mini-cannon", "Mini Cannon", EquipmentSlot.Weapon, Rarity.Uncommon, "Small explosive shells damage clustered Bloons."),
				Item("ricochet-gun", "Ricochet Gun", EquipmentSlot.Weapon, Rarity.Uncommon, "Shots bounce between Bloons.", "Chain"),
				Item("poison-dart-gun", "Poison Dart Gun", EquipmentSlot.Weapon, Rarity.Uncommon, "Darts inflict poison damage over time.", "Poison"),
				Item("rapid-chaos-bow", "Rapid Chaos Bow", EquipmentSlot.Weapon, Rarity.Uncommon, "Fast chaos arrows pressure the front of the track.", "Chaos"),
				Item("plasma-rifle", "Plasma Rifle", EquipmentSlot.Weapon, Rarity.Rare, "High-pierce plasma shots.", "Plasma"),
				Item("gravity-cannon", "Gravity Cannon", EquipmentSlot.Weapon, Rarity.Rare, "Impacts create a small pulling force.", "Gravity"),
				Item("chain-lightning-staff", "Chain Lightning Staff", EquipmentSlot.Weapon, Rarity.Rare, "Lightning jumps between nearby Bloons.", "Lightning"),
				Item("frost-launcher", "Frost Launcher", EquipmentSlot.Weapon, Rarity.Rare, "Chilling shells slow Bloons on hit.", "Frost"),
				Item("meteor-cannon", "Meteor Cannon", EquipmentSlot.Weapon, Rarity.Rare, "Occasionally calls down a meteor strike.", "Meteor"),
				Item("void-blaster", "Void Blaster", EquipmentSlot.Weapon, Rarity.Epic, "Piercing void projectiles.", "Void"),
				Item("soul-reaper", "Soul Reaper", EquipmentSlot.Weapon, Rarity.Epic, "Deals bonus damage to already damaged Bloons.", "Soul"),
				Item("black-hole-launcher", "Black Hole Launcher", EquipmentSlot.Weapon, Rarity.Epic, "Small black holes form on impact.", "Gravity", "Void"),
				Item("chaos-accelerator", "Chaos Accelerator", EquipmentSlot.Weapon, Rarity.Epic, "Consecutive hits on the same target become stronger.", "Chaos"),
				Item("reality-rifle", "Reality Rifle", EquipmentSlot.Weapon, Rarity.Legendary, "High-pierce shots sometimes ignore normal Bloon physics.", "Reality"),
				Item("dragon-cannon", "Dragon Cannon", EquipmentSlot.Weapon, Rarity.Legendary, "Continuous dragonfire beam.", "Fire"),
				Item("time-breaker", "Time Breaker", EquipmentSlot.Weapon, Rarity.Legendary, "Hits can briefly slow their target.", "Time"),
				Item("void-destroyer", "Void Destroyer", EquipmentSlot.Weapon, Rarity.Mythic, "Creates damaging rifts.", "Void"),
				Item("judgement-cannon", "Judgement Cannon", EquipmentSlot.Weapon, Rarity.Mythic, "Slow devastating shots scale against stronger targets.", "Moab"),
				Item("eternal-chaos", "Eternal Chaos", EquipmentSlot.Weapon, Rarity.Godly, "Random chaos effect on attack.", "Chaos"),
				Item("genesis-weapon", "Genesis", EquipmentSlot.Weapon, Rarity.Godly, "Adapts its attack to the currently equipped build.", "Genesis", "Chaos"),
				Item("basic-ammo", "Basic Ammo", EquipmentSlot.Ammo, Rarity.Common, "Reliable standard ammunition with no hidden drawback."),
				Item("sharp-ammo", "Sharp Ammo", EquipmentSlot.Ammo, Rarity.Common, "Adds a little pierce so each projectile reaches one more Bloon."),
				Item("heavy-ammo", "Heavy Ammo", EquipmentSlot.Ammo, Rarity.Common, "Heavier rounds deal extra direct damage but travel more slowly."),
				Item("rapid-ammo", "Rapid Ammo", EquipmentSlot.Ammo, Rarity.Common, "Light rounds increase firing rhythm at the cost of impact strength."),
				Item("explosive-ammo", "Explosive Ammo", EquipmentSlot.Ammo, Rarity.Common, "Creates a small splash explosion when a projectile hits.", "Fire"),
				Item("homing-ammo", "Homing Ammo", EquipmentSlot.Ammo, Rarity.Common, "Projectiles gently correct their path toward the current target."),
				Item("piercing-ammo", "Piercing Ammo", EquipmentSlot.Ammo, Rarity.Common, "A clean pierce bonus for long straight lanes."),
				Item("bounce-ammo", "Bounce Ammo", EquipmentSlot.Ammo, Rarity.Common, "Projectiles can rebound once into a nearby Bloon.", "Chain"),
				Item("burning-ammo", "Burning Ammo", EquipmentSlot.Ammo, Rarity.Uncommon, "Applies burning damage over time to hit Bloons.", "Fire"),
				Item("freezing-ammo", "Freezing Ammo", EquipmentSlot.Ammo, Rarity.Uncommon, "Strongly chills hit Bloons for a short time.", "Frost"),
				Item("poison-ammo", "Poison Ammo", EquipmentSlot.Ammo, Rarity.Uncommon, "Inflicts a lasting poison damage-over-time effect.", "Poison"),
				Item("piercing-plasma", "Piercing Plasma", EquipmentSlot.Ammo, Rarity.Uncommon, "Concentrated plasma rounds punch through dense packs.", "Plasma"),
				Item("shocking-ammo", "Shocking Ammo", EquipmentSlot.Ammo, Rarity.Uncommon, "Each hit has a chance to release a small chain lightning.", "Lightning"),
				Item("vampire-ammo", "Vampire Ammo", EquipmentSlot.Ammo, Rarity.Uncommon, "A portion of dealt damage restores the Chaos Monkey.", "Vampire"),
				Item("lightning-ammo", "Lightning Ammo", EquipmentSlot.Ammo, Rarity.Rare, "Lightning leaps from the struck Bloon to several nearby targets.", "Lightning"),
				Item("gravity-ammo", "Gravity Ammo", EquipmentSlot.Ammo, Rarity.Rare, "Impacts pull nearby Bloons toward a shared point.", "Gravity"),
				Item("void-ammo", "Void Ammo", EquipmentSlot.Ammo, Rarity.Rare, "Creates small damaging tears in the void behind impacts.", "Void"),
				Item("meteor-ammo", "Meteor Ammo", EquipmentSlot.Ammo, Rarity.Rare, "Occasionally calls a meteor down onto the target area.", "Meteor"),
				Item("time-ammo", "Time Ammo", EquipmentSlot.Ammo, Rarity.Rare, "Hit Bloons suffer a localized time-slow effect.", "Time"),
				Item("soul-ammo", "Soul Ammo", EquipmentSlot.Ammo, Rarity.Epic, "Marks enemies so marked Bloons take additional damage.", "Soul"),
				Item("black-flame-ammo", "Black Flame Ammo", EquipmentSlot.Ammo, Rarity.Epic, "Black fire partly ignores ordinary Bloon immunities.", "Fire", "Reality"),
				Item("chaos-split-ammo", "Chaos Split Ammo", EquipmentSlot.Ammo, Rarity.Epic, "Projectiles split into several smaller chaotic shots on impact.", "Chaos"),
				Item("reality-ammo", "Reality Ammo", EquipmentSlot.Ammo, Rarity.Epic, "Shots can ignore selected Bloon properties and resistances.", "Reality"),
				Item("dragonfire-ammo", "Dragonfire Ammo", EquipmentSlot.Ammo, Rarity.Legendary, "Every direct hit produces a short spreading fire wave.", "Fire"),
				Item("singularity-ammo", "Singularity Ammo", EquipmentSlot.Ammo, Rarity.Legendary, "Hits briefly create a compact gravity point.", "Gravity", "Void"),
				Item("chrono-ammo", "Chrono Ammo", EquipmentSlot.Ammo, Rarity.Legendary, "Greatly slows Bloons caught in its warped time field.", "Time"),
				Item("oblivion-ammo", "Oblivion Ammo", EquipmentSlot.Ammo, Rarity.Mythic, "Can temporarily strip part of a struck Bloon's special properties.", "Oblivion", "Reality"),
				Item("rift-ammo", "Rift Ammo", EquipmentSlot.Ammo, Rarity.Mythic, "Opens a damaging void rift that harms nearby Bloons over time.", "Void"),
				Item("law-of-chaos-ammo", "Law of Chaos", EquipmentSlot.Ammo, Rarity.Godly, "Every shot receives one random chaos effect: fire, freeze, gravity, void, lightning or time.", "Chaos"),
				Item("genesis-ammo", "Genesis Ammo", EquipmentSlot.Ammo, Rarity.Godly, "Adapts to the equipped weapon and amplifies that weapon's own special effect.", "Genesis", "Chaos"),
				Item("basic-body", "Basic Body", EquipmentSlot.Body, Rarity.Common, "Small all-round bonuses to damage and pierce."),
				Item("light-body", "Light Body", EquipmentSlot.Body, Rarity.Common, "A lighter frame increases attack speed."),
				Item("heavy-body", "Heavy Body", EquipmentSlot.Body, Rarity.Common, "A sturdy frame increases damage but reduces attack speed."),
				Item("scout-body", "Scout Body", EquipmentSlot.Body, Rarity.Common, "Improves attack range and target visibility."),
				Item("lucky-body", "Lucky Body", EquipmentSlot.Body, Rarity.Common, "Adds a small bonus to chance-based effects.", "Luck"),
				Item("reinforced-body", "Reinforced Body", EquipmentSlot.Body, Rarity.Common, "Increases durability and resists light pressure."),
				Item("swift-body", "Swift Body", EquipmentSlot.Body, Rarity.Common, "Shortens ability cooldowns a little."),
				Item("focused-body", "Focused Body", EquipmentSlot.Body, Rarity.Common, "Adds focused damage against one durable target.", "Moab"),
				Item("inferno-body", "Inferno Body", EquipmentSlot.Body, Rarity.Uncommon, "Resists fire and periodically emits a small flame pulse.", "Fire"),
				Item("frost-body", "Frost Body", EquipmentSlot.Body, Rarity.Uncommon, "Strengthens chilling and freeze combinations.", "Frost"),
				Item("toxic-body", "Toxic Body", EquipmentSlot.Body, Rarity.Uncommon, "Surrounds the Monkey with a damaging poison aura.", "Poison"),
				Item("storm-body", "Storm Body", EquipmentSlot.Body, Rarity.Uncommon, "Periodically releases lightning around the Monkey.", "Lightning"),
				Item("hunter-body", "Hunter Body", EquipmentSlot.Body, Rarity.Uncommon, "Improves target acquisition and tracking.", "Hunter"),
				Item("vampire-body", "Vampire Body", EquipmentSlot.Body, Rarity.Uncommon, "Strengthens healing gained from lifesteal effects.", "Vampire"),
				Item("gravity-body", "Gravity Body", EquipmentSlot.Body, Rarity.Rare, "Creates a small aura that pulls nearby Bloons together.", "Gravity"),
				Item("void-body", "Void Body", EquipmentSlot.Body, Rarity.Rare, "Gives attacks a chance to leave a short-lived void rift.", "Void"),
				Item("chrono-body", "Chrono Body", EquipmentSlot.Body, Rarity.Rare, "Periodically slows nearby Bloons by warping time.", "Time"),
				Item("dragon-body", "Dragon Body", EquipmentSlot.Body, Rarity.Rare, "Adds an occasional short fire-breath passive.", "Fire"),
				Item("titan-body", "Titan Body", EquipmentSlot.Body, Rarity.Rare, "A heavily defensive body suited to holding strong lanes."),
				Item("soul-body", "Soul Body", EquipmentSlot.Body, Rarity.Epic, "Weakened Bloons become soul-marked for extra finishing damage.", "Soul"),
				Item("reality-body", "Reality Body", EquipmentSlot.Body, Rarity.Epic, "Partially bypasses selected Bloon properties.", "Reality"),
				Item("black-hole-body", "Black Hole Body", EquipmentSlot.Body, Rarity.Epic, "Occasionally forms a small black hole near the track.", "Gravity", "Void"),
				Item("chaos-core-body", "Chaos Core Body", EquipmentSlot.Body, Rarity.Epic, "Cycles through damage, pierce, speed and range bonuses.", "Chaos"),
				Item("eternal-body", "Eternal Body", EquipmentSlot.Body, Rarity.Legendary, "Provides powerful defense and steady regeneration."),
				Item("celestial-body", "Celestial Body", EquipmentSlot.Body, Rarity.Legendary, "Energy pulses amplify the other equipped item effects.", "Celestial"),
				Item("time-lord-body", "Time Lord Body", EquipmentSlot.Body, Rarity.Legendary, "Strongly enhances all nearby time manipulation.", "Time"),
				Item("oblivion-body", "Oblivion Body", EquipmentSlot.Body, Rarity.Mythic, "Neutralizes selected negative Bloon properties around the Monkey.", "Oblivion"),
				Item("world-eater-body", "World Eater Body", EquipmentSlot.Body, Rarity.Mythic, "Grows stronger while more MOAB-class Bloons remain on the map.", "Moab"),
				Item("celestial-core", "Celestial Core", EquipmentSlot.Body, Rarity.Godly, "A floating core regularly empowers the other five equipment slots.", "Celestial"),
				Item("singularity-body", "Singularity Body", EquipmentSlot.Body, Rarity.Godly, "A black core occasionally creates a powerful black hole.", "Gravity", "Void"),
				Item("basic-cap", "Basic Cap", EquipmentSlot.Head, Rarity.Common, "Simple target focus for dependable First targeting."),
				Item("scout-goggles", "Scout Goggles", EquipmentSlot.Head, Rarity.Common, "Extends vision and makes fast targets easier to track."),
				Item("focus-helmet", "Focus Helmet", EquipmentSlot.Head, Rarity.Common, "Improves precise damage against the currently selected target."),
				Item("heavy-helmet", "Heavy Helmet", EquipmentSlot.Head, Rarity.Common, "A reinforced helm adds a small defensive bonus."),
				Item("lucky-hat", "Lucky Hat", EquipmentSlot.Head, Rarity.Common, "Adds a small chance-based bonus to the current build.", "Luck"),
				Item("ranger-hood", "Ranger Hood", EquipmentSlot.Head, Rarity.Common, "Improves range and long-lane targeting."),
				Item("flame-crown", "Flame Crown", EquipmentSlot.Head, Rarity.Uncommon, "Increases the reach of fire effects.", "Fire"),
				Item("frost-helmet", "Frost Helmet", EquipmentSlot.Head, Rarity.Uncommon, "Freeze and chill effects last longer.", "Frost"),
				Item("storm-helmet", "Storm Helmet", EquipmentSlot.Head, Rarity.Uncommon, "Lightning effects can acquire additional nearby targets.", "Lightning"),
				Item("hunters-mask", "Hunter's Mask", EquipmentSlot.Head, Rarity.Uncommon, "Greatly improves homing and target prediction.", "Hunter"),
				Item("vampire-hood", "Vampire Hood", EquipmentSlot.Head, Rarity.Uncommon, "Enhances the healing gained through lifesteal.", "Vampire"),
				Item("chrono-visor", "Chrono Visor", EquipmentSlot.Head, Rarity.Uncommon, "Makes time effects more accurate and reliable.", "Time"),
				Item("gravity-crown", "Gravity Crown", EquipmentSlot.Head, Rarity.Rare, "Gravity pulls gain radius and duration.", "Gravity"),
				Item("void-mask", "Void Mask", EquipmentSlot.Head, Rarity.Rare, "Void tears and rifts remain active for longer.", "Void"),
				Item("dragon-helm", "Dragon Helm", EquipmentSlot.Head, Rarity.Rare, "Improves direct fire and dragon-breath damage.", "Fire"),
				Item("soul-mask", "Soul Mask", EquipmentSlot.Head, Rarity.Rare, "Soul-marked enemies take stronger finishing damage.", "Soul"),
				Item("meteor-crown", "Meteor Crown", EquipmentSlot.Head, Rarity.Rare, "Meteor effects strike more reliably and with a larger impact.", "Meteor"),
				Item("reality-mask", "Reality Mask", EquipmentSlot.Head, Rarity.Epic, "Partially ignores selected Bloon properties and resistances.", "Reality"),
				Item("chaos-helmet", "Chaos Helmet", EquipmentSlot.Head, Rarity.Epic, "Raises the strength of random chaos effects.", "Chaos"),
				Item("eclipse-halo", "Eclipse Halo", EquipmentSlot.Head, Rarity.Epic, "A dark halo periodically pulses void energy around the Monkey.", "Void", "Gravity"),
				Item("soul-crown", "Soul Crown", EquipmentSlot.Head, Rarity.Epic, "Boosts soul marks and the damage dealt to marked targets.", "Soul"),
				Item("crown-of-fate", "Crown of Fate", EquipmentSlot.Head, Rarity.Legendary, "Improves long-term chance effects and critical outcomes.", "Luck"),
				Item("celestial-crown", "Celestial Crown", EquipmentSlot.Head, Rarity.Legendary, "Celestial pulses enhance nearby equipment effects.", "Celestial"),
				Item("time-crown", "Time Crown", EquipmentSlot.Head, Rarity.Legendary, "Strongly enhances slowing and time-control effects.", "Time"),
				Item("crown-of-oblivion", "Crown of Oblivion", EquipmentSlot.Head, Rarity.Mythic, "Oblivion marks make targets vulnerable to void and reality damage.", "Oblivion"),
				Item("crown-of-worlds", "Crown of Worlds", EquipmentSlot.Head, Rarity.Mythic, "Draws power from the whole map and strengthens large-area effects.", "Reality"),
				Item("crown-of-infinity", "Crown of Infinity", EquipmentSlot.Head, Rarity.Godly, "Amplifies every Godly item in the current loadout.", "Celestial"),
				Item("black-halo", "Black Halo", EquipmentSlot.Head, Rarity.Godly, "A Godly eclipse ring empowers gravity, void and reality builds.", "Gravity", "Void", "Reality"),
				Item("quick-learner", "Quick Learner", EquipmentSlot.Trait, Rarity.Common, "Increases general attack speed."),
				Item("bloodthirsty", "Bloodthirsty", EquipmentSlot.Trait, Rarity.Common, "Deals more damage to already damaged Bloons."),
				Item("greedy", "Greedy", EquipmentSlot.Trait, Rarity.Uncommon, "Occasionally generates a small amount of bonus map cash."),
				Item("lucky", "Lucky", EquipmentSlot.Trait, Rarity.Uncommon, "Slightly improves every chance-based combat effect.", "Luck"),
				Item("focused", "Focused", EquipmentSlot.Trait, Rarity.Rare, "Deals more damage to strong and MOAB-class targets.", "Moab"),
				Item("chaotic", "Chaotic", EquipmentSlot.Trait, Rarity.Rare, "Each attack can receive a small random temporary bonus.", "Chaos"),
				Item("berserker", "Berserker", EquipmentSlot.Trait, Rarity.Epic, "The lower the Monkey's health, the stronger its attacks become."),
				Item("gambler", "Gambler", EquipmentSlot.Trait, Rarity.Epic, "Rarely produces an extremely amplified critical hit.", "Chaos"),
				Item("overclocked", "Overclocked", EquipmentSlot.Trait, Rarity.Epic, "Abilities recharge faster while normal attacks are slightly weaker."),
				Item("fate-trait", "Fate", EquipmentSlot.Trait, Rarity.Legendary, "Makes certain random events increasingly likely over a long fight.", "Luck"),
				Item("chaos-affinity", "Chaos Affinity", EquipmentSlot.Trait, Rarity.Legendary, "Greatly strengthens Chaos-tag synergies.", "Chaos"),
				Item("reality-bender", "Reality Bender", EquipmentSlot.Trait, Rarity.Mythic, "Dynamically bends selected combat rules in the build's favour.", "Reality"),
				Item("absolute-luck", "Absolute Luck", EquipmentSlot.Trait, Rarity.Godly, "Greatly raises proc power and random-effect strength.", "Luck"),
				Item("law-of-chaos-trait", "Law of Chaos", EquipmentSlot.Trait, Rarity.Godly, "Random effects can become substantially stronger or stranger.", "Chaos"),
				Item("chaos-blast", "Chaos Blast", EquipmentSlot.Ability, Rarity.Common, "Detonates a small chaos blast at the selected location.", "Chaos"),
				Item("rapid-fire", "Rapid Fire", EquipmentSlot.Ability, Rarity.Common, "Temporarily gives the equipped weapon a rapid firing rhythm."),
				Item("freeze-burst", "Freeze Burst", EquipmentSlot.Ability, Rarity.Uncommon, "Releases a burst that heavily chills nearby Bloons.", "Frost"),
				Item("lightning-strike", "Lightning Strike", EquipmentSlot.Ability, Rarity.Uncommon, "Calls a targeted lightning strike onto the track.", "Lightning"),
				Item("gravity-pulse", "Gravity Pulse", EquipmentSlot.Ability, Rarity.Rare, "Pulls nearby Bloons into a compact target cluster.", "Gravity"),
				Item("time-slow", "Time Slow", EquipmentSlot.Ability, Rarity.Rare, "Temporarily slows Bloons in a large part of the track.", "Time"),
				Item("meteor-shower", "Meteor Shower", EquipmentSlot.Ability, Rarity.Epic, "Calls several meteors across the map.", "Meteor"),
				Item("void-rift", "Void Rift", EquipmentSlot.Ability, Rarity.Epic, "Creates a large damaging void rift.", "Void"),
				Item("soul-harvest", "Soul Harvest", EquipmentSlot.Ability, Rarity.Epic, "Marks many Bloons, then deals a delayed burst to every marked target.", "Soul"),
				Item("dragon-breath", "Dragon Breath", EquipmentSlot.Ability, Rarity.Legendary, "Unleashes a powerful continuous fire beam.", "Fire"),
				Item("black-hole", "Black Hole", EquipmentSlot.Ability, Rarity.Legendary, "Creates a large black hole that pulls and damages nearby Bloons.", "Gravity", "Void"),
				Item("time-stop", "Time Stop", EquipmentSlot.Ability, Rarity.Legendary, "Strongly slows time around the Monkey for a limited duration.", "Time"),
				Item("oblivion", "Oblivion", EquipmentSlot.Ability, Rarity.Mythic, "Deals enormous area damage and removes selected Bloon properties.", "Oblivion", "Reality"),
				Item("reality-collapse", "Reality Collapse", EquipmentSlot.Ability, Rarity.Mythic, "Creates overlapping reality rifts across a large area of the map.", "Reality"),
				Item("ascendant-chaos", "Ascendant Chaos", EquipmentSlot.Ability, Rarity.Godly, "Activates fire, lightning, meteors, void rifts and gravity wells together.", "Chaos"),
				Item("genesis-ability", "Genesis", EquipmentSlot.Ability, Rarity.Godly, "Analyzes all six equipped items and creates a build-specific chaos effect.", "Genesis", "Chaos"),
				Item("the-unwritten-blade", "The Unwritten Blade", EquipmentSlot.Weapon, Rarity.Secret, "A black blade that can make Camo, Regrow or Fortified properties disappear.", "Secret", "Galaxy", "Reality"),
				Item("event-horizon", "Event Horizon", EquipmentSlot.Weapon, Rarity.Secret, "Creates tiny singularities at target points; stronger Bloons create stronger collapses.", "Secret", "Galaxy", "Gravity"),
				Item("null-weapon", "[NULL]", EquipmentSlot.Weapon, Rarity.Secret, "It appears to fire nothing, then Bloons simply vanish outside normal damage rules.", "Secret", "Galaxy", "Null"),
				Item("forbidden-matter", "Forbidden Matter", EquipmentSlot.Ammo, Rarity.Secret, "Each hit leaves corruption; enough corruption detonates the Bloon.", "Secret", "Galaxy", "Corruption"),
				Item("yesterday", "Yesterday", EquipmentSlot.Ammo, Rarity.Secret, "Hit Bloons can be sent back to an earlier position on the track.", "Secret", "Galaxy", "Time"),
				Item("outside", "Outside", EquipmentSlot.Ammo, Rarity.Secret, "Shots pass obstacles, bypass protected targets and can reappear behind them.", "Secret", "Galaxy", "Reality"),
				Item("observer-body", "Observer Body", EquipmentSlot.Body, Rarity.Secret, "A watching eye marks Bloons that remain in view for escalating damage.", "Secret", "Galaxy", "Observer"),
				Item("singularity-core", "Singularity Core", EquipmentSlot.Body, Rarity.Secret, "Nearby Bloons are drawn inward; more nearby Bloons create more power.", "Secret", "Galaxy", "Gravity"),
				Item("forgotten-body", "Forgotten Body", EquipmentSlot.Body, Rarity.Secret, "A half-transparent body that causes some Bloons to lose their normal recognition.", "Secret", "Galaxy", "Forgotten"),
				Item("watching-eye", "The Watching Eye", EquipmentSlot.Head, Rarity.Secret, "Predicts Bloon movement and grants exceptionally precise targeting.", "Secret", "Galaxy", "Observer"),
				Item("crown-of-nothing", "Crown of Nothing", EquipmentSlot.Head, Rarity.Secret, "Periodically removes a negative effect and can erase enemy properties.", "Secret", "Galaxy", "Reality"),
				Item("the-black-halo", "The Black Halo", EquipmentSlot.Head, Rarity.Secret, "A black ring slows and draws Bloons together before releasing a gravity wave.", "Secret", "Galaxy", "Gravity"),
				Item("impossible-luck", "Impossible Luck", EquipmentSlot.Trait, Rarity.Secret, "Every roll quietly receives an additional invisible luck check.", "Secret", "Galaxy", "Luck"),
				Item("fate-secret", "Fate", EquipmentSlot.Trait, Rarity.Secret, "A hidden counter grows while the Monkey lives, then triggers a powerful random event.", "Secret", "Galaxy", "Fate"),
				Item("existence", "Existence", EquipmentSlot.Trait, Rarity.Secret, "Some normal game rules cannot affect the Monkey; every slot receives a small bonus.", "Secret", "Galaxy", "Reality"),
				Item("erase", "Erase", EquipmentSlot.Ability, Rarity.Secret, "Marks a target, then erases normal Bloons or deals huge boss and BAD damage after a delay.", "Secret", "Galaxy", "Reality"),
				Item("rewind", "Rewind", EquipmentSlot.Ability, Rarity.Secret, "Rolls Bloons back to earlier positions and repeats part of their recent damage.", "Secret", "Galaxy", "Time"),
				Item("unknown-ability", "???", EquipmentSlot.Ability, Rarity.Secret, "After a silent delay, triggers an unpredictable map-wide Secret effect.", "Secret", "Galaxy", "Null")
			});
		}

		public ItemDefinition Pick(EquipmentSlot slot, Rarity rarity, Random random)
		{
			ItemDefinition[] array = items.Where((ItemDefinition item) => item.Slot == slot && item.Rarity == rarity).ToArray();
			if (array.Length == 0)
			{
				throw new InvalidOperationException($"No {rarity} item exists for {slot}.");
			}
			return array[random.Next(array.Length)];
		}

		public IEnumerable<ItemDefinition> All()
		{
			return items;
		}

		public ItemDefinition Find(string id)
		{
			if (LegacyItemIds.TryGetValue(id, out string value))
			{
				id = value;
			}
			return items.Single((ItemDefinition item) => item.Id == id);
		}

		private static ItemDefinition Item(string id, string name, EquipmentSlot slot, Rarity rarity, string summary, params string[] tags)
		{
			return new ItemDefinition(id, name, slot, rarity, new HashSet<string>(tags, StringComparer.OrdinalIgnoreCase), summary);
		}

		private static void Validate(IEnumerable<ItemDefinition> source)
		{
			IGrouping<string, ItemDefinition> grouping = (from item in source
				group item by item.Id).FirstOrDefault((IGrouping<string, ItemDefinition> group) => group.Count() > 1);
			if (grouping != null)
			{
				throw new InvalidOperationException("Duplicate item id: " + grouping.Key + ".");
			}
			EquipmentSlot[] equipmentSlots = DomainValues.EquipmentSlots;
			foreach (EquipmentSlot slot in equipmentSlots)
			{
				Rarity[] rarities = DomainValues.Rarities;
				foreach (Rarity rarity in rarities)
				{
					if (!source.Any((ItemDefinition item) => item.Slot == slot && item.Rarity == rarity))
					{
						throw new InvalidOperationException($"Catalogue requires one {rarity} item for {slot}.");
					}
				}
			}
		}
	}
	public sealed class ChaosMonkeyMatchState
	{
		private readonly Dictionary<EquipmentSlot, ItemDefinition?> equipment = DomainValues.EquipmentSlots.ToDictionary((EquipmentSlot slot) => slot, (EquipmentSlot _) => (ItemDefinition)null);

		private readonly HashSet<EquipmentSlot> lockedSlots = new HashSet<EquipmentSlot>();

		public int Shards { get; private set; }

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

		public int TotalRolls { get; private set; }

		public int NormalRolls { get; private set; }

		public int RandomUnlockAtNormalRoll { get; }

		public PityState Pity { get; } = new PityState();

		public EvolutionState Evolution { get; } = new EvolutionState();

		public bool IsDeveloperLoadout { get; private set; }

		public bool RandomRollUnlocked => NormalRolls >= RandomUnlockAtNormalRoll;

		public IReadOnlyDictionary<EquipmentSlot, ItemDefinition?> Equipment => equipment;

		public bool CanSell
		{
			get
			{
				if (!Evolution.IsInProgress)
				{
					return !Evolution.IsComplete;
				}
				return false;
			}
		}

		public ChaosMonkeyMatchState(Random random, int startingShards = 50)
		{
			if (random == null)
			{
				throw new ArgumentNullException("random");
			}
			if (startingShards < 0)
			{
				throw new ArgumentOutOfRangeException("startingShards");
			}
			RandomUnlockAtNormalRoll = random.Next(5, 11);
			Shards = startingShards;
		}

		private ChaosMonkeyMatchState(int randomUnlockAtNormalRoll)
		{
			if ((randomUnlockAtNormalRoll < 5 || randomUnlockAtNormalRoll > 10) ? true : false)
			{
				throw new ArgumentOutOfRangeException("randomUnlockAtNormalRoll");
			}
			RandomUnlockAtNormalRoll = randomUnlockAtNormalRoll;
		}

		public bool IsSlotLocked(EquipmentSlot slot)
		{
			return lockedSlots.Contains(slot);
		}

		public ItemDefinition? GetItem(EquipmentSlot slot)
		{
			return equipment[slot];
		}

		public void AddShards(int amount)
		{
			if (amount <= 0)
			{
				throw new ArgumentOutOfRangeException("amount");
			}
			checked
			{
				Shards += amount;
			}
		}

		public bool TrySpendShards(int amount)
		{
			if (amount <= 0)
			{
				throw new ArgumentOutOfRangeException("amount");
			}
			if (Shards < amount)
			{
				return false;
			}
			Shards -= amount;
			return true;
		}

		public void PurchaseLuck(int newMultiplier)
		{
			int? num = null;
			for (int i = 0; i < ChaosEconomy.PurchasableLuck.Count - 1; i++)
			{
				if (ChaosEconomy.PurchasableLuck[i] == PurchasedLuck)
				{
					num = ChaosEconomy.PurchasableLuck[i + 1];
					break;
				}
			}
			if (num != newMultiplier)
			{
				throw new ArgumentOutOfRangeException("newMultiplier", "Luck must be purchased in the configured order.");
			}
			PurchasedLuck = newMultiplier;
		}

		public void SetSlotLock(EquipmentSlot slot, bool isLocked)
		{
			if (Evolution.IsInProgress || Evolution.IsComplete)
			{
				throw new InvalidOperationException("Equipment is locked during and after evolution.");
			}
			if (isLocked)
			{
				lockedSlots.Add(slot);
			}
			else
			{
				lockedSlots.Remove(slot);
			}
		}

		internal void Equip(EquipmentSlot slot, ItemDefinition item, RollMode mode)
		{
			if (Evolution.IsInProgress || Evolution.IsComplete || IsSlotLocked(slot))
			{
				throw new InvalidOperationException("This slot cannot be changed.");
			}
			equipment[slot] = item;
			TotalRolls++;
			if (mode == RollMode.Normal)
			{
				NormalRolls++;
			}
		}

		public void EquipDeveloper(ItemDefinition item)
		{
			if ((object)item == null)
			{
				throw new ArgumentNullException("item");
			}
			if (Evolution.IsInProgress || Evolution.IsComplete || IsSlotLocked(item.Slot))
			{
				throw new InvalidOperationException("This slot cannot be changed.");
			}
			equipment[item.Slot] = item;
			IsDeveloperLoadout = true;
		}

		public EvolutionKind GetAvailableEvolution()
		{
			if (!equipment.Values.All((ItemDefinition item) => (object)item != null && item.Rarity == Rarity.Secret))
			{
				if (!equipment.Values.All((ItemDefinition item) => (object)item != null && item.Rarity == Rarity.Godly))
				{
					return EvolutionKind.None;
				}
				return EvolutionKind.ChaosAscendant;
			}
			return EvolutionKind.SecretAscension;
		}

		public void StartEvolution(Random random)
		{
			EvolutionKind availableEvolution = GetAvailableEvolution();
			if (availableEvolution == EvolutionKind.None)
			{
				throw new InvalidOperationException("A full Godly or Secret build is required.");
			}
			Evolution.Start(availableEvolution, random.Next((availableEvolution == EvolutionKind.ChaosAscendant) ? 10 : 20, (availableEvolution == EvolutionKind.ChaosAscendant) ? 21 : 31));
			EquipmentSlot[] equipmentSlots = DomainValues.EquipmentSlots;
			foreach (EquipmentSlot item in equipmentSlots)
			{
				lockedSlots.Add(item);
			}
		}

		public ChaosMonkeyMatchSnapshot ToSnapshot()
		{
			return new ChaosMonkeyMatchSnapshot(Shards, PurchasedLuck, TotalRolls, NormalRolls, RandomUnlockAtNormalRoll, Pity.ToSnapshot(), Evolution.ToSnapshot(), equipment.ToDictionary<KeyValuePair<EquipmentSlot, ItemDefinition>, EquipmentSlot, string>((KeyValuePair<EquipmentSlot, ItemDefinition> pair) => pair.Key, (KeyValuePair<EquipmentSlot, ItemDefinition> pair) => pair.Value?.Id), (IReadOnlyCollection<EquipmentSlot>)(object)lockedSlots.ToArray(), IsDeveloperLoadout);
		}

		public static ChaosMonkeyMatchState FromSnapshot(ChaosMonkeyMatchSnapshot snapshot, ItemCatalog catalog)
		{
			if ((object)snapshot == null)
			{
				throw new ArgumentNullException("snapshot");
			}
			if (catalog == null)
			{
				throw new ArgumentNullException("catalog");
			}
			if (!ChaosEconomy.PurchasableLuck.Contains(snapshot.PurchasedLuck))
			{
				throw new InvalidOperationException("Unknown saved Luck value.");
			}
			ChaosMonkeyMatchState chaosMonkeyMatchState = new ChaosMonkeyMatchState(snapshot.RandomUnlockAtNormalRoll)
			{
				Shards = snapshot.Shards,
				PurchasedLuck = snapshot.PurchasedLuck,
				TotalRolls = snapshot.TotalRolls,
				NormalRolls = snapshot.NormalRolls,
				IsDeveloperLoadout = snapshot.IsDeveloperLoadout
			};
			chaosMonkeyMatchState.Pity.Load(snapshot.Pity);
			chaosMonkeyMatchState.Evolution.Load(snapshot.Evolution);
			EquipmentSlot[] equipmentSlots = DomainValues.EquipmentSlots;
			foreach (EquipmentSlot key in equipmentSlots)
			{
				if (snapshot.Equipment.TryGetValue(key, out string value) && value != null)
				{
					chaosMonkeyMatchState.equipment[key] = catalog.Find(value);
				}
			}
			foreach (EquipmentSlot lockedSlot in snapshot.LockedSlots)
			{
				chaosMonkeyMatchState.lockedSlots.Add(lockedSlot);
			}
			return chaosMonkeyMatchState;
		}
	}
	public sealed record ChaosMonkeyMatchSnapshot(int Shards, int PurchasedLuck, int TotalRolls, int NormalRolls, int RandomUnlockAtNormalRoll, PitySnapshot Pity, EvolutionSnapshot Evolution, IReadOnlyDictionary<EquipmentSlot, string?> Equipment, IReadOnlyCollection<EquipmentSlot> LockedSlots, bool IsDeveloperLoadout = false);
	public sealed class EvolutionState
	{
		public EvolutionKind Kind { get; private set; }

		public int RoundsRequired { get; private set; }

		public int RoundsCompleted { get; private set; }

		public bool IsInProgress
		{
			get
			{
				if (Kind != EvolutionKind.None)
				{
					return RoundsCompleted < RoundsRequired;
				}
				return false;
			}
		}

		public bool IsComplete
		{
			get
			{
				if (Kind != EvolutionKind.None)
				{
					return RoundsCompleted >= RoundsRequired;
				}
				return false;
			}
		}

		public void Start(EvolutionKind kind, int roundsRequired)
		{
			if (kind == EvolutionKind.None || roundsRequired <= 0 || Kind != EvolutionKind.None)
			{
				throw new InvalidOperationException("Evolution cannot be started.");
			}
			Kind = kind;
			RoundsRequired = roundsRequired;
		}

		public bool AdvanceRound()
		{
			if (!IsInProgress)
			{
				return false;
			}
			RoundsCompleted++;
			return IsComplete;
		}

		public EvolutionSnapshot ToSnapshot()
		{
			return new EvolutionSnapshot(Kind, RoundsRequired, RoundsCompleted);
		}

		internal void Load(EvolutionSnapshot snapshot)
		{
			Kind = snapshot.Kind;
			RoundsRequired = snapshot.RoundsRequired;
			RoundsCompleted = snapshot.RoundsCompleted;
		}
	}
	public sealed record EvolutionSnapshot(EvolutionKind Kind, int RoundsRequired, int RoundsCompleted);
	public sealed record AchievementDefinition(string Id, string Title, string Description, bool IsSecret = false);
	public static class AchievementCatalog
	{
		public static readonly IReadOnlyList<AchievementDefinition> Definitions = new AchievementDefinition[10]
		{
			new AchievementDefinition("hello-chaos", "Hello, Chaos", "Place your first Chaos Monkey."),
			new AchievementDefinition("roll-10", "Hurra!", "Perform 10 rolls."),
			new AchievementDefinition("roll-100", "Roller", "Perform 100 rolls."),
			new AchievementDefinition("first-legendary", "That is pretty rare", "Find your first Legendary item."),
			new AchievementDefinition("first-mythic", "WHAT?!", "Find your first Mythic item."),
			new AchievementDefinition("first-godly", "UNBELIEVABLE", "Find your first Godly item."),
			new AchievementDefinition("first-synergy", "First Combo", "Activate your first synergy."),
			new AchievementDefinition("ascension", "Ascension", "Complete Chaos Ascendant evolution."),
			new AchievementDefinition("the-unknown", "THE UNKNOWN", "Discover your first Secret.", IsSecret: true),
			new AchievementDefinition("beyond-god", "BEYOND GOD", "Complete Secret Ascension.", IsSecret: true)
		};
	}
	public sealed class ProfileProgress
	{
		private readonly HashSet<string> unlockedAchievements = new HashSet<string>(StringComparer.Ordinal);

		private readonly HashSet<string> uniqueSecretItemIds = new HashSet<string>(StringComparer.Ordinal);

		public int TotalRolls { get; private set; }

		public int TotalRandomRolls { get; private set; }

		public int LegendaryFinds { get; private set; }

		public int MythicFinds { get; private set; }

		public int GodlyFinds { get; private set; }

		public int SecretFinds { get; private set; }

		public int GodlyEvolutions { get; private set; }

		public int SecretEvolutions { get; private set; }

		public IReadOnlyCollection<string> UnlockedAchievementIds => unlockedAchievements;

		public IReadOnlyCollection<string> UniqueSecretItemIds => uniqueSecretItemIds;

		public bool IsAchievementVisible(AchievementDefinition achievement)
		{
			if (achievement.IsSecret)
			{
				return unlockedAchievements.Contains(achievement.Id);
			}
			return true;
		}

		public void RecordPlacement()
		{
			Unlock("hello-chaos");
		}

		public void RecordRoll(RollResult result)
		{
			TotalRolls++;
			if (result.Mode == RollMode.Random)
			{
				TotalRandomRolls++;
			}
			if (result.Item.Rarity >= Rarity.Legendary && !result.IsSecret)
			{
				LegendaryFinds++;
			}
			if (result.Item.Rarity >= Rarity.Mythic && !result.IsSecret)
			{
				MythicFinds++;
			}
			if (result.Item.Rarity == Rarity.Godly)
			{
				GodlyFinds++;
			}
			if (result.IsSecret)
			{
				SecretFinds++;
				uniqueSecretItemIds.Add(result.Item.Id);
				Unlock("the-unknown");
			}
			if (TotalRolls >= 10)
			{
				Unlock("roll-10");
			}
			if (TotalRolls >= 100)
			{
				Unlock("roll-100");
			}
			if (LegendaryFinds >= 1)
			{
				Unlock("first-legendary");
			}
			if (MythicFinds >= 1)
			{
				Unlock("first-mythic");
			}
			if (GodlyFinds >= 1)
			{
				Unlock("first-godly");
			}
		}

		public void RecordSynergies(IEnumerable<SynergyDefinition> activeSynergies)
		{
			if (activeSynergies.Any())
			{
				Unlock("first-synergy");
			}
		}

		public void RecordEvolution(EvolutionKind kind)
		{
			switch (kind)
			{
			case EvolutionKind.ChaosAscendant:
				GodlyEvolutions++;
				Unlock("ascension");
				break;
			case EvolutionKind.SecretAscension:
				SecretEvolutions++;
				Unlock("beyond-god");
				break;
			}
		}

		private void Unlock(string achievementId)
		{
			unlockedAchievements.Add(achievementId);
		}

		public ProfileProgressSnapshot ToSnapshot()
		{
			return new ProfileProgressSnapshot(TotalRolls, TotalRandomRolls, LegendaryFinds, MythicFinds, GodlyFinds, SecretFinds, GodlyEvolutions, SecretEvolutions, (IReadOnlyCollection<string>)(object)unlockedAchievements.ToArray(), (IReadOnlyCollection<string>)(object)uniqueSecretItemIds.ToArray());
		}

		public static ProfileProgress FromSnapshot(ProfileProgressSnapshot snapshot)
		{
			if ((object)snapshot == null)
			{
				throw new ArgumentNullException("snapshot");
			}
			ProfileProgress profileProgress = new ProfileProgress
			{
				TotalRolls = snapshot.TotalRolls,
				TotalRandomRolls = snapshot.TotalRandomRolls,
				LegendaryFinds = snapshot.LegendaryFinds,
				MythicFinds = snapshot.MythicFinds,
				GodlyFinds = snapshot.GodlyFinds,
				SecretFinds = snapshot.SecretFinds,
				GodlyEvolutions = snapshot.GodlyEvolutions,
				SecretEvolutions = snapshot.SecretEvolutions
			};
			foreach (string unlockedAchievementId in snapshot.UnlockedAchievementIds)
			{
				profileProgress.unlockedAchievements.Add(unlockedAchievementId);
			}
			foreach (string uniqueSecretItemId in snapshot.UniqueSecretItemIds)
			{
				profileProgress.uniqueSecretItemIds.Add(uniqueSecretItemId);
			}
			return profileProgress;
		}
	}
	public sealed record ProfileProgressSnapshot(int TotalRolls, int TotalRandomRolls, int LegendaryFinds, int MythicFinds, int GodlyFinds, int SecretFinds, int GodlyEvolutions, int SecretEvolutions, IReadOnlyCollection<string> UnlockedAchievementIds, IReadOnlyCollection<string> UniqueSecretItemIds);
	public sealed record SynergyDefinition(string Id, string DisplayName, IReadOnlyCollection<string> RequiredItemIds, string Summary, bool IsGodly = false, bool IsSecret = false, bool IsFullSet = false);
	public static class SynergyCatalog
	{
		public static readonly IReadOnlyList<SynergyDefinition> Definitions = new SynergyDefinition[22]
		{
			new SynergyDefinition("absolute-zero", "Absolute Zero", (IReadOnlyCollection<string>)(object)new string[2] { "frost-launcher", "freezing-ammo" }, "Chill becomes much stronger and frozen Bloons take additional damage."),
			new SynergyDefinition("inferno", "Inferno", (IReadOnlyCollection<string>)(object)new string[2] { "mini-cannon", "burning-ammo" }, "Explosions ignite nearby Bloons."),
			new SynergyDefinition("gravity-master", "Gravity Master", (IReadOnlyCollection<string>)(object)new string[2] { "gravity-ammo", "gravity-body" }, "Gravity pulls become stronger and wider."),
			new SynergyDefinition("thunderstorm", "Thunderstorm", (IReadOnlyCollection<string>)(object)new string[2] { "chain-lightning-staff", "lightning-ammo" }, "Lightning chains gain additional targets."),
			new SynergyDefinition("void-walker", "Void Walker", (IReadOnlyCollection<string>)(object)new string[2] { "void-destroyer", "void-ammo" }, "Void rifts last longer and deal more damage."),
			new SynergyDefinition("dragon-soul", "Dragon Soul", (IReadOnlyCollection<string>)(object)new string[2] { "dragon-cannon", "dragon-body" }, "An additional short dragon-breath attack joins the weapon beam."),
			new SynergyDefinition("time-lord", "Time Lord", (IReadOnlyCollection<string>)(object)new string[2] { "time-lord-body", "time-ammo" }, "Slowed Bloons remain slowed for much longer."),
			new SynergyDefinition("meteor-lord", "Meteor Lord", (IReadOnlyCollection<string>)(object)new string[2] { "meteor-ammo", "meteor-shower" }, "Meteors grow larger and strike for more area damage."),
			new SynergyDefinition("storm-god", "Storm God", (IReadOnlyCollection<string>)(object)new string[3] { "chain-lightning-staff", "lightning-ammo", "storm-helmet" }, "Lightning can jump broadly and occasionally becomes a super strike."),
			new SynergyDefinition("singularity", "Singularity", (IReadOnlyCollection<string>)(object)new string[3] { "black-hole-launcher", "singularity-body", "black-halo" }, "Black holes merge and explode when their pull ends."),
			new SynergyDefinition("void-master", "Void Master", (IReadOnlyCollection<string>)(object)new string[3] { "void-destroyer", "void-ammo", "void-mask" }, "Rifts become larger and deal additional damage."),
			new SynergyDefinition("absolute-zero-master", "Absolute Zero Master", (IReadOnlyCollection<string>)(object)new string[3] { "frost-launcher", "freezing-ammo", "frost-helmet" }, "Powerful enemies are massively slowed even when they cannot be fully frozen."),
			new SynergyDefinition("dragon-emperor", "Dragon Emperor", (IReadOnlyCollection<string>)(object)new string[3] { "dragon-cannon", "dragon-body", "dragon-breath" }, "Adds a second dragon beam to the Chaos Monkey."),
			new SynergyDefinition("time-keeper", "Time Keeper", (IReadOnlyCollection<string>)(object)new string[3] { "chrono-body", "time-ammo", "chrono-visor" }, "Time effects grow stronger and abilities recharge faster."),
			new SynergyDefinition("godly-resonance", "Godly Resonance", (IReadOnlyCollection<string>)(object)new string[3] { "eternal-chaos", "law-of-chaos-ammo", "celestial-core" }, "Godly chaos effects can reinforce one another.", IsGodly: true),
			new SynergyDefinition("celestial-resonance", "Celestial Resonance", (IReadOnlyCollection<string>)(object)new string[2] { "celestial-core", "crown-of-infinity" }, "The core regularly sends an empowering pulse through the loadout.", IsGodly: true),
			new SynergyDefinition("absolute-fate", "Absolute Fate", (IReadOnlyCollection<string>)(object)new string[2] { "absolute-luck", "law-of-chaos-ammo" }, "Random Chaos effects can resolve at their strongest tier.", IsGodly: true),
			new SynergyDefinition("infinity", "Infinity", (IReadOnlyCollection<string>)(object)new string[3] { "crown-of-infinity", "celestial-core", "genesis-weapon" }, "Genesis gains an additional Chaos Rift and faster ability recovery.", IsGodly: true),
			new SynergyDefinition("the-observer", "The Observer", (IReadOnlyCollection<string>)(object)new string[2] { "observer-body", "watching-eye" }, "Observed Bloons are marked and continuously weakened.", IsGodly: false, IsSecret: true),
			new SynergyDefinition("endless-gravity", "Endless Gravity", (IReadOnlyCollection<string>)(object)new string[2] { "singularity-core", "the-black-halo" }, "The two gravity fields merge into a stronger shared pull.", IsGodly: false, IsSecret: true),
			new SynergyDefinition("paradox", "Paradox", (IReadOnlyCollection<string>)(object)new string[2] { "yesterday", "rewind" }, "Rewind can cause a second shorter time jump.", IsGodly: false, IsSecret: true),
			new SynergyDefinition("null-resonance", "NULL RESONANCE", (IReadOnlyCollection<string>)(object)new string[2] { "null-weapon", "unknown-ability" }, "Reality flickers and the resulting Secret effect is deliberately unpredictable.", IsGodly: false, IsSecret: true)
		};

		public static readonly SynergyDefinition CompleteGodlyHarmony = new SynergyDefinition("complete-godly-harmony", "Godly Chaos Harmony", (IReadOnlyCollection<string>)(object)Array.Empty<string>(), "FULL SET • CHAOS EFFECTS RESONATE ACROSS ALL SIX SLOTS.", IsGodly: true, IsSecret: false, IsFullSet: true);

		public static readonly SynergyDefinition CompleteSecretHarmony = new SynergyDefinition("complete-secret-harmony", "Secret Galaxy Harmony", (IReadOnlyCollection<string>)(object)Array.Empty<string>(), "FULL SET • GALAXY, VOID, AND REALITY EFFECTS ACT AS ONE.", IsGodly: false, IsSecret: true, IsFullSet: true);
	}
	public sealed class SynergyResolver
	{
		public IReadOnlyList<SynergyDefinition> Resolve(IReadOnlyDictionary<EquipmentSlot, ItemDefinition?> equipment)
		{
			if (equipment == null)
			{
				throw new ArgumentNullException("equipment");
			}
			HashSet<string> itemIds = new HashSet<string>(from item in equipment.Values
				where (object)item != null
				select item.Id, StringComparer.Ordinal);
			List<SynergyDefinition> list = SynergyCatalog.Definitions.Where((SynergyDefinition definition) => definition.RequiredItemIds.All(itemIds.Contains)).ToList();
			ItemDefinition value;
			bool num = DomainValues.EquipmentSlots.All((EquipmentSlot slot) => equipment.TryGetValue(slot, out value) && (object)value != null && value.Rarity == Rarity.Godly);
			bool flag = DomainValues.EquipmentSlots.All((EquipmentSlot slot) => equipment.TryGetValue(slot, out value) && (object)value != null && value.Rarity == Rarity.Secret);
			if (num)
			{
				list.Add(SynergyCatalog.CompleteGodlyHarmony);
			}
			if (flag)
			{
				list.Add(SynergyCatalog.CompleteSecretHarmony);
			}
			return list;
		}
	}
	public static class ChaosMonkeyMatchStateTestSupport
	{
		public static void EquipForTest(this ChaosMonkeyMatchState state, EquipmentSlot slot, ItemDefinition item)
		{
			state.Equip(slot, item, RollMode.Normal);
		}
	}
}