using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BTD_Mod_Helper;
using BTD_Mod_Helper.Api;
using BTD_Mod_Helper.Api.Components;
using BTD_Mod_Helper.Api.ModOptions;
using BTD_Mod_Helper.Extensions;
using HarmonyLib;
using Il2Cpp;
using Il2CppAssets.Scripts.Data.ParagonData;
using Il2CppAssets.Scripts.Models;
using Il2CppAssets.Scripts.Models.Effects;
using Il2CppAssets.Scripts.Models.Entities;
using Il2CppAssets.Scripts.Models.Towers;
using Il2CppAssets.Scripts.Models.Towers.Behaviors;
using Il2CppAssets.Scripts.Models.Towers.Upgrades;
using Il2CppAssets.Scripts.Simulation.Objects;
using Il2CppAssets.Scripts.Simulation.SMath;
using Il2CppAssets.Scripts.Simulation.Towers;
using Il2CppAssets.Scripts.Simulation.Towers.Behaviors;
using Il2CppAssets.Scripts.Unity;
using Il2CppAssets.Scripts.Unity.Bridge;
using Il2CppAssets.Scripts.Unity.UI_New.InGame;
using Il2CppAssets.Scripts.Unity.UI_New.InGame.TowerSelectionMenu;
using Il2CppAssets.Scripts.Unity.UI_New.Popups;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;
using Il2CppTMPro;
using MelonLoader;
using Microsoft.CodeAnalysis;
using Paragonomics;
using UnityEngine;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: MelonInfo(typeof(ParagonomicsMod), "Paragonomics", "1.0.6", "doombubbles", null)]
[assembly: MelonGame("Ninja Kiwi", "BloonsTD6")]
[assembly: MelonGame("Ninja Kiwi", "BloonsTD6-Epic")]
[assembly: MelonOptionalDependencies(new string[] { "BuffsInShop" })]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("Paragonomics")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+cd122a2d9a79721a1b928fd6b43b65f55d643544")]
[assembly: AssemblyProduct("Paragonomics")]
[assembly: AssemblyTitle("Paragonomics")]
[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 Paragonomics
{
	public static class Calculations
	{
		public static readonly Queue<int> DegreeCalculationHints = new Queue<int>();

		public static double DegreeToPower(long d)
		{
			if (1 == 0)
			{
			}
			double result;
			if (d > 0)
			{
				if (d <= 100)
				{
					if (d != 1)
					{
						if (d != 100)
						{
							goto IL_0066;
						}
						result = 200000.0;
					}
					else
					{
						result = 0.0;
					}
				}
				else
				{
					if (!ModSettingBool.op_Implicit(ParagonomicsMod.LinearScalingPastLimit))
					{
						goto IL_0066;
					}
					result = d * 2000;
				}
			}
			else
			{
				result = 0.0 - DegreeToPower(-d + 1);
			}
			goto IL_00c1;
			IL_0066:
			result = Math.Round((50.0 * Math.Pow(d, 3.0) + 5025.0 * Math.Pow(d, 2.0) + (double)(168324 * d) + 843000.0) / 600.0);
			goto IL_00c1;
			IL_00c1:
			if (1 == 0)
			{
			}
			return result;
		}

		public static long PowerToDegree(double power)
		{
			if (power != 0.0)
			{
				if (!(power < 0.0))
				{
					if (power != 200000.0)
					{
						if (power > 200000.0 && ModSettingBool.op_Implicit(ParagonomicsMod.LinearScalingPastLimit))
						{
							return (long)Math.Round(power / 2000.0);
						}
						if (!DegreeCalculationHints.TryDequeue(out var result))
						{
							result = 100;
						}
						double num = result;
						for (int i = 1; i < 100; i++)
						{
							double num2 = DegreeToPower((long)num);
							double num3 = DegreeToPower((long)num + 1);
							if (num2 <= power && num3 > power)
							{
								return (long)num;
							}
							double num4 = num2 - power;
							double num5 = (150.0 * Math.Pow(num, 2.0) + 10050.0 * num + 168324.0) / 600.0;
							double num6 = num4 / num5;
							num -= num6;
							num = Math.Max(1.0, num);
						}
						return (int)num;
					}
					return 100L;
				}
				return Math.Min(-PowerToDegree(0.0 - power) + 1, -1L);
			}
			return 1L;
		}

		public static int GetDisplayDegreeIndex(ParagonTower paragon, int degree)
		{
			Il2CppReferenceArray<AssetPathModel> displayDegreePaths = paragon.paragonTowerModel.displayDegreePaths;
			if (!((IEnumerable<AssetPathModel>)displayDegreePaths).Any())
			{
				return -1;
			}
			Il2CppStructArray<int> powerDegreeRequirements = ((RootObject)paragon).Sim.model.paragonDegreeDataModel.powerDegreeRequirements;
			return Math.Min(degree / (((Il2CppArrayBase<int>)(object)powerDegreeRequirements).Length / ((Il2CppArrayBase<AssetPathModel>)(object)displayDegreePaths).Length), ((Il2CppArrayBase<int>)(object)powerDegreeRequirements).Length - 1);
		}

		public static float GetCostFactor(ParagonTower paragon)
		{
			string baseId = ((EntityModel)((TowerBehavior)paragon).tower.towerModel).baseId;
			GameModel model = ((RootObject)paragon).Sim.model;
			float num = Math.Max(model.GetTower(baseId, 0, 0, 0).cost, 1f) * 3f;
			int num2 = (from tower in Il2CppGenericIEnumerable.AsIEnumerable<TowerModel>(model.GetTowersWithBaseId(baseId, false))
				where !tower.isParagon
				select tower).SelectMany((TowerModel tower) => (IEnumerable<string>)tower.appliedUpgrades).Distinct().Select((Func<string, UpgradeModel>)model.GetUpgrade)
				.Sum((UpgradeModel upgrade) => Math.Max(upgrade.cost, 1));
			int num3 = Math.Max(ParagonomicsMod.GetParagonUpgrade(((TowerBehavior)paragon).tower).cost, 10);
			return (num + (float)num2) / (num + (float)num2 + (float)num3);
		}

		public static float FactorForBaseDegree(float factor, int baseDegree)
		{
			return 100f * ((1f / factor - 1f) / (float)baseDegree);
		}

		public static PowerDegreeMutator GetDegreeMutator(ParagonTower paragon, int degree, AssetPathModel displayDegree)
		{
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Expected O, but got Unknown
			ParagonDegreeDataModel paragonDegreeDataModel = InGame.Bridge.Simulation.model.paragonDegreeDataModel;
			int num = degree - 1;
			float num2 = Math.Sign((float)num) * Math.Round(Math.Sqrt(Math.Abs((float)num) * paragonDegreeDataModel.attackCooldownReductionX) * 10f) / 10f;
			float num3 = (float)num * paragonDegreeDataModel.piercePercentPerDegree;
			float num4 = (float)num * paragonDegreeDataModel.pierceIncreasePerDegree;
			float num5 = (float)num * paragonDegreeDataModel.damagePercentPerDegree;
			float num6 = (float)num / paragonDegreeDataModel.damageIncreaseForDegrees * paragonDegreeDataModel.damageIncreasePerDegree;
			if (degree >= paragonDegreeDataModel.degreeCount)
			{
				num3 += paragonDegreeDataModel.piercePercentPerDegree;
				num4 += paragonDegreeDataModel.piercePercentPerDegree;
				num6 += paragonDegreeDataModel.damageIncreasePerDegree;
			}
			float num7 = 0f;
			if (degree >= paragonDegreeDataModel.bonusBossDamagePerDegrees)
			{
				num7 = (float)(degree / paragonDegreeDataModel.bonusBossDamagePerDegrees) * paragonDegreeDataModel.bonusBossDamagePercent;
			}
			int num8 = GetDisplayDegreeIndex(paragon, degree) + 1;
			if (num < 0)
			{
				num6 = Math.Max(0f, num6);
				num4 = Math.Max(0f, num4);
				float costFactor = GetCostFactor(paragon);
				float num9 = FactorForBaseDegree(costFactor, 29) * (1f + num2 / 100f);
				num3 = 0f - (100f + 10000f / (-100f + num3 * num9));
				num5 = 0f - (100f + 10000f / (-100f + num5 * num9));
			}
			return new PowerDegreeMutator(degree, num2, num3, num4, num5, (float)(int)num6, num8, displayDegree, paragon.paragonTowerModel.changeAttackDisplay, paragon.paragonTowerModel.changeAirUnitDisplay, num7);
		}
	}
	public static class ModHelperData
	{
		public const string WorksOnVersion = "54.0";

		public const string Version = "1.0.6";

		public const string Name = "Paragonomics";

		public const string Description = "Adds new ways to change Paragon degrees using cash.\n\nSubprime Paragons: Buy negative degree paragons for less cash than normal.\nParagon Investing: Spend cash to increase paragon degree after creation.\nSet Degree: Directly set paragon degree in Sandbox mode.";

		public const string RepoOwner = "doombubbles";

		public const string PrevRepoName = "paragonomics";

		public const string RepoName = "Paragonomics";
	}
	public class ParagonomicsMod : BloonsTD6Mod
	{
		public const int MinimumCostFactor = 100;

		public static readonly ModSettingBool AllowDegreeSettingOutsideSandbox = new ModSettingBool(false)
		{
			description = "Allows the cheat-y Set Degree feature to be used outside Sandbox mode.",
			icon = "1bf486871cae1224ca90cf52c1965462"
		};

		public static readonly ModSettingBool NoDegreeLimit = new ModSettingBool(false)
		{
			description = "Removes the standard degree 100 limit for the purposes of investing and degree setting.",
			icon = "1757f8ef9167a3842b6d977f379d8548"
		};

		public static readonly ModSettingBool LinearScalingPastLimit = new ModSettingBool(false)
		{
			description = "Makes the power investment requirement scaling be linear when the degree increases beyond 100, rather than continuing to be exponentially more."
		};

		public override object? Call(string operation, params object[] p)
		{
			if (1 == 0)
			{
			}
			float investment = default(float);
			object result = ((!(operation == "GetDegree") || !ArrayExt.CheckTypes<float>(p, ref investment)) ? null : ((object)GetDegree(investment)));
			if (1 == 0)
			{
			}
			return result;
		}

		public static void DegreeBtnPressed(ParagonTower paragon)
		{
			Calculations.DegreeCalculationHints.Enqueue(paragon.GetCurrentDegree());
			PopupScreenExt.SafelyQueue(PopupScreen.instance, (Action<PopupScreen>)delegate(PopupScreen screen)
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				screen.ShowSetValuePopup("Set Paragon Degree", "Directly set the degree of this paragon at no cost.", Action<int>.op_Implicit((Action<int>)delegate(int degree)
				{
					SetDegree(paragon, degree);
				}), GetDegree(paragon.investmentInfo.totalInvestment));
			});
		}

		public static UpgradeModel GetParagonUpgrade(Tower tower)
		{
			GameModel val = (((Object)(object)InGame.instance != (Object)null) ? InGame.Bridge.Model : Game.instance.model);
			BloonsMod val2 = default(BloonsMod);
			return (((Mutable)tower).IsMutatedBy("HonoraryParagon") && ModHelper.HasMod("HonoraryParagons", ref val2)) ? val2.Call<UpgradeModel>("GetParagonUpgrade", new object[2] { val, tower.towerModel }) : val.GetParagonUpgradeForTowerId(((EntityModel)tower.towerModel).baseId);
		}

		public static bool HasEnoughToShowPopup(Tower tower)
		{
			UpgradeModel paragonUpgrade = GetParagonUpgrade(tower);
			if (InGame.Bridge.GetCash(-1) * 100.0 >= (double)paragonUpgrade.cost)
			{
				return true;
			}
			StartPopup();
			PopupScreenExt.SafelyQueue(PopupScreen.instance, (Action<PopupScreen>)delegate(PopupScreen screen)
			{
				screen.ShowOkPopup("You must have at least 1% of the Paragon's Cost in cash.", ReturnCallback.op_Implicit((Action)FinishPopup));
			});
			return false;
		}

		public static void InvestBtnPressed(ParagonTower paragon, Action<double>? okCallback = null, Action? cancelCallback = null)
		{
			if (!HasEnoughToShowPopup(((TowerBehavior)paragon).tower))
			{
				return;
			}
			StartPopup();
			PopupScreenExt.SafelyQueue(PopupScreen.instance, (Action<PopupScreen>)delegate(PopupScreen screen)
			{
				screen.ShowParagonConfirmationPopup((Placement)0, "Invest in Paragon", "Add to your current Paragon Power investment.", Action<double>.op_Implicit((Action<double>)delegate(double cash)
				{
					FinishPopup();
					InvestInParagon(paragon, cash);
					okCallback?.Invoke(cash);
				}), "Do It", Action.op_Implicit((Action)delegate
				{
					FinishPopup();
					cancelCallback?.Invoke();
				}), "Cancel", (TransitionAnim)1, (int)InGame.Bridge.GetCash(-1), int.MaxValue, 0);
			});
		}

		public static void NegativeParagonPopup(TowerSelectionMenu tsm, int index)
		{
			if (!HasEnoughToShowPopup(tsm.selectedTower.tower))
			{
				return;
			}
			UpgradeModel upgrade = GetParagonUpgrade(tsm.selectedTower.tower);
			int minCost = upgrade.cost / 100;
			if (tsm.Bridge.GetCash(-1) >= (double)upgrade.cost || tsm.Bridge.GetCash(-1) < (double)minCost || !TowerSelectionMenuUtils.CanUpgradeToParagon(tsm.selectedTower, true))
			{
				return;
			}
			StartPopup();
			PopupScreenExt.SafelyQueue(PopupScreen.instance, (Action<PopupScreen>)delegate(PopupScreen screen)
			{
				screen.ShowParagonConfirmationPopup((Placement)0, "Subprime Paragon", "You dont have enough cash to initiate a full Paragon sacrifice. However, you can spend the cash you do have to get a weaker, Negative-Degree Paragon and invest more later.", Action<double>.op_Implicit((Action<double>)delegate(double amount)
				{
					FinishPopup();
					tsm.isUpgradePopupShowing = false;
					double num = amount + (double)minCost;
					Tower tower = tsm.selectedTower.tower;
					tsm.UpgradeTower(upgrade, index, (float)num, num - (double)upgrade.cost);
					tower.worth -= (float)upgrade.cost;
					tower.worth += (float)num;
				}), "Do It", Action.op_Implicit((Action)FinishPopup), "Cancel", (TransitionAnim)1, (int)InGame.Bridge.GetCash(-1) - minCost, upgrade.cost, minCost);
			});
		}

		public static void StartPopup()
		{
			InGame.instance.StopClock(true);
			InGame.instance.hotkeys.SuppressHotkeys = true;
			TowerSelectionMenuExt.instance.isUpgradePopupShowing = true;
		}

		public static void FinishPopup()
		{
			InGame.instance.ResumeClock(true);
			InGame.instance.hotkeys.SuppressHotkeys = false;
			TowerSelectionMenuExt.instance.isUpgradePopupShowing = false;
		}

		public static int GetDegree(float investment)
		{
			ParagonDegreeDataModel paragonDegreeDataModel = InGame.Bridge.Model.paragonDegreeDataModel;
			Il2CppStructArray<int> powerDegreeRequirements = paragonDegreeDataModel.powerDegreeRequirements;
			if (investment < 0f || (investment > (float)paragonDegreeDataModel.MaxInvestment && ModSettingBool.op_Implicit(NoDegreeLimit)))
			{
				return (int)Calculations.PowerToDegree(investment);
			}
			int i;
			for (i = 0; i < ((Il2CppArrayBase<int>)(object)powerDegreeRequirements).Length && investment >= (float)((Il2CppArrayBase<int>)(object)powerDegreeRequirements)[i]; i++)
			{
			}
			return i;
		}

		public static void SetDegree(ParagonTower paragon, int degree)
		{
			//IL_0060: 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_0031: 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)
			GameModel model = ((RootObject)paragon).Sim.model;
			ParagonDegreeDataModel paragonDegreeDataModel = model.paragonDegreeDataModel;
			if (degree < 1 || degree > ((Il2CppArrayBase<int>)(object)paragonDegreeDataModel.powerDegreeRequirements).Length)
			{
				paragon.investmentInfo = new InvestmentInfo
				{
					totalInvestment = (float)Calculations.DegreeToPower(degree)
				};
				Calculations.DegreeCalculationHints.Enqueue(degree);
			}
			else
			{
				paragon.investmentInfo = new InvestmentInfo
				{
					totalInvestment = ((Il2CppArrayBase<int>)(object)paragonDegreeDataModel.powerDegreeRequirements)[degree - 1]
				};
			}
			OnDegreeChanged(paragon);
		}

		public static void InvestInParagon(ParagonTower paragon, double investment)
		{
			//IL_0045: 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_004e: 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)
			ParagonDegreeDataModel paragonDegreeDataModel = ((RootObject)paragon).Sim.model.paragonDegreeDataModel;
			int cost = GetParagonUpgrade(((TowerBehavior)paragon).tower).cost;
			float num = (float)investment * paragonDegreeDataModel.moneySpentOverX / ((1f + paragonDegreeDataModel.paidContributionPenalty) * (float)Math.Max(cost, 1));
			InvestmentInfo investmentInfo = paragon.investmentInfo;
			investmentInfo.totalInvestment = paragon.investmentInfo.totalInvestment + num;
			paragon.investmentInfo = investmentInfo;
			OnDegreeChanged(paragon);
			InGame.Bridge.SetCash(InGame.Bridge.GetCash(-1) - investment);
		}

		public static void OnDegreeChanged(ParagonTower paragon)
		{
			paragon.UpdateDegree();
			paragon.PlayParagonUpgradeSound();
			paragon.Finish();
			Il2CppGenericIEnumerable.ForEach<TowerCreateParagonTower>(((RootBehavior)paragon).entity.GetBehaviorsInDependants<TowerCreateParagonTower>(), (Action<TowerCreateParagonTower>)delegate(TowerCreateParagonTower tower)
			{
				tower.towerAdded = false;
			});
			TowerSelectionMenu instance = TowerSelectionMenuExt.instance;
			object obj;
			if (instance == null)
			{
				obj = null;
			}
			else
			{
				TowerToSimulation selectedTower = instance.selectedTower;
				obj = ((selectedTower != null) ? selectedTower.tower : null);
			}
			if (obj == ((TowerBehavior)paragon).tower)
			{
				TowerSelectionMenuExt.instance.OnTowerSelectionPanelForceUpdate();
			}
		}
	}
	[HarmonyPatch(typeof(TowerSelectionMenu), "UpdateParagon")]
	internal static class TowerSelectionMenu_UpdateParagon
	{
		[HarmonyPostfix]
		internal static void Postfix(TowerSelectionMenu __instance)
		{
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Expected O, but got Unknown
			//IL_0103: 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_0121: 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_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			GameObject gameObject = ((Component)((TMP_Text)__instance.paragonDegree).transform.parent).gameObject;
			if (!Object.op_Implicit((Object)(object)gameObject.GetComponent<Button>()) && (ModSettingBool.op_Implicit(ParagonomicsMod.AllowDegreeSettingOutsideSandbox) || __instance.Bridge.IsSandboxMode()))
			{
				Button val = gameObject.AddComponent<Button>();
				((Selectable)val).transition = (Transition)3;
				Animator val2 = gameObject.AddComponent<Animator>();
				val2.runtimeAnimatorController = Animations.GlobalButtonAnimation;
				val2.updateMode = (AnimatorUpdateMode)2;
				((Graphic)gameObject.GetComponent<Image>()).raycastTarget = true;
				ButtonExt.SetOnClick(val, (Function)delegate
				{
					ParagonomicsMod.DegreeBtnPressed(TowerBehaviorExt.GetTowerBehavior<ParagonTower>(__instance.selectedTower.tower));
				});
			}
			if (!Object.op_Implicit((Object)(object)GameObjectExt.GetComponentInChildrenByName<ModHelperButton>(__instance.paragonDetails, "ParagonomicsBtn")))
			{
				RectTransform val3 = ((Il2CppObjectBase)__instance.paragonDetails.transform.Find("ParagonInfo/ParagonTitle")).Cast<RectTransform>();
				Info val4 = default(Info);
				((Info)(ref val4))..ctor("ParagonomicsBtn");
				((Info)(ref val4)).set_AnchorMin(val3.anchorMin);
				((Info)(ref val4)).set_AnchorMax(val3.anchorMax);
				((Info)(ref val4)).set_Pivot(val3.pivot);
				((Info)(ref val4)).set_Position(Vector2.op_Implicit(((Transform)val3).localPosition));
				Rect rect = val3.rect;
				((Info)(ref val4)).set_Height(((Rect)(ref rect)).height);
				rect = val3.rect;
				((Info)(ref val4)).set_Width(((Rect)(ref rect)).width + 50f);
				ModHelperButton val5 = ModHelperButton.Create(val4, "Ui[ParagonBtnLong]", Action.op_Implicit((Action)delegate
				{
					ParagonomicsMod.InvestBtnPressed(TowerBehaviorExt.GetTowerBehavior<ParagonTower>(__instance.selectedTower.tower));
				}));
				((ModHelperComponent)val5).SetParent(((Transform)val3).parent);
				((Transform)val3).SetParent(((Component)val5).transform);
				val3.anchorMin = new Vector2(0f, 0f);
				val3.anchorMax = new Vector2(1f, 1f);
				val3.pivot = new Vector2(0.5f, 0.5f);
				val3.sizeDelta = new Vector2(0f, 0f);
				((Transform)val3).localPosition = new Vector3(0f, 10f, 0f);
			}
		}
	}
	[HarmonyPatch(typeof(ParagonTower), "GetDegreeMutator")]
	internal static class ParagonTower_GetDegreeMutator
	{
		[HarmonyPostfix]
		internal static void Postfix(ParagonTower __instance, AssetPathModel displayDegree, float investment, ref PowerDegreeMutator __result)
		{
			ParagonDegreeDataModel paragonDegreeDataModel = ((RootObject)__instance).Sim.model.paragonDegreeDataModel;
			if (investment < 0f || (investment > (float)paragonDegreeDataModel.MaxInvestment && ModSettingBool.op_Implicit(ParagonomicsMod.NoDegreeLimit)))
			{
				__result = Calculations.GetDegreeMutator(__instance, ParagonomicsMod.GetDegree(investment), displayDegree);
			}
		}
	}
	[HarmonyPatch(typeof(TowerSelectionMenu), "UpgradeTower", new Type[]
	{
		typeof(int),
		typeof(bool)
	})]
	internal static class TowerSelectionMenu_UpgradeTower
	{
		[HarmonyPrefix]
		internal static void Prefix(TowerSelectionMenu __instance, int index)
		{
			if (index >= ((Il2CppArrayBase<UpgradeObject>)(object)__instance.upgradeButtons).Length)
			{
				return;
			}
			UpgradeObject obj = ((Il2CppArrayBase<UpgradeObject>)(object)__instance.upgradeButtons)[index];
			if (obj != null)
			{
				UpgradeButton upgradeButton = obj.upgradeButton;
				if (((upgradeButton != null) ? new bool?(upgradeButton.IsParagon) : ((bool?)null)) == true)
				{
					ParagonomicsMod.NegativeParagonPopup(__instance, index);
				}
			}
		}
	}
	[HarmonyPatch(typeof(UpgradeButton), "UpdateCostVisuals")]
	internal static class UpgradeButton_UpdateCostVisuals
	{
		[HarmonyPostfix]
		internal static void Postfix(UpgradeButton __instance)
		{
			double cash = InGame.Bridge.GetCash(-1);
			if (__instance.IsParagon && cash < (double)__instance.upgradeCost && __instance.tts != null && cash * 100.0 >= (double)__instance.upgradeCost)
			{
				string text = __instance.upgradeCost.ToString(CultureInfo.InvariantCulture);
				NK_TextMeshProUGUI cost = __instance.Cost;
				string text2 = text;
				cost.SetText("<color=green>" + text2.Substring(0, text2.Length - 2) + "</color>" + text.Substring(text.Length - 2));
			}
		}
	}
	[HarmonyPatch(typeof(TowerCreateParagonTower), "GetParagonTowerModelTier")]
	internal static class TowerCreateParagonTower_GetParagonTowerModelTier
	{
		[HarmonyPrefix]
		internal static bool Prefix(TowerCreateParagonTower __instance, ref TowerModel __result)
		{
			int currentDegree = __instance.paragonTower.GetCurrentDegree();
			if (currentDegree >= 1)
			{
				return true;
			}
			__result = ((Il2CppArrayBase<TowerModel>)(object)__instance.behaviourModel.towerModels)[0];
			return false;
		}
	}
}