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.Display;
using BTD_Mod_Helper.Api.Helpers;
using BTD_Mod_Helper.Api.ModOptions;
using BTD_Mod_Helper.Api.Towers;
using BTD_Mod_Helper.Extensions;
using CardMonkey;
using CardMonkey.Displays.Projectiles;
using CardMonkey.Upgrades.MiddlePath;
using Il2Cpp;
using Il2CppAssets.Scripts.Models;
using Il2CppAssets.Scripts.Models.Effects;
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.Abilities;
using Il2CppAssets.Scripts.Models.Towers.Behaviors.Abilities.Behaviors;
using Il2CppAssets.Scripts.Models.Towers.Behaviors.Attack;
using Il2CppAssets.Scripts.Models.Towers.Behaviors.Attack.Behaviors;
using Il2CppAssets.Scripts.Models.Towers.Behaviors.Emissions;
using Il2CppAssets.Scripts.Models.Towers.Behaviors.Emissions.Behaviors;
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.Models.Towers.Weapons.Behaviors;
using Il2CppAssets.Scripts.Simulation.SMath;
using Il2CppAssets.Scripts.Unity;
using Il2CppAssets.Scripts.Unity.Display;
using Il2CppAssets.Scripts.Unity.UI_New.InGame;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppNinjaKiwi.Common.ResourceUtils;
using MelonLoader;
using Microsoft.CodeAnalysis;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: MelonInfo(typeof(CardMonkeyMod), "Card Monkey", "1.2.19", "doombubbles", null)]
[assembly: MelonGame("Ninja Kiwi", "BloonsTD6")]
[assembly: MelonGame("Ninja Kiwi", "BloonsTD6-Epic")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("CardMonkey")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+5be57b3cf4fe933c09a3b144f040af2430ddffcf")]
[assembly: AssemblyProduct("CardMonkey")]
[assembly: AssemblyTitle("CardMonkey")]
[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 CardMonkey
{
	public class CardMonkey : ModTower
	{
		public override TowerSet TowerSet => (TowerSet)1;

		public override string BaseTower => TowerType.DartMonkey;

		public override int Cost => 400;

		public override string Description => "Throws playing cards at Bloons";

		public override ParagonMode ParagonMode => (ParagonMode)2;

		public override ModSettingHotkey Hotkey => CardMonkeyMod.CardMonkeyHotkey;

		public override bool IncludeInRogueLegends => true;

		public override void ModifyBaseTowerModel(TowerModel towerModel)
		{
			towerModel.range += 10f;
			AttackModel attackModel = TowerModelExt.GetAttackModel(towerModel);
			attackModel.range += 10f;
			ProjectileModel projectile = ((Il2CppArrayBase<WeaponModel>)(object)attackModel.weapons)[0].projectile;
			ProjectileModelExt.ApplyDisplay<RedCardDisplay>(projectile);
			projectile.pierce += 2f;
		}

		public override int GetTowerIndex(List<TowerDetailsModel> towerSet)
		{
			return towerSet.First((TowerDetailsModel model) => model.towerId == TowerType.BoomerangMonkey).towerIndex + 1;
		}

		public override bool IsValidCrosspath(params int[] tiers)
		{
			return ModHelper.HasMod("UltimateCrosspathing") || ((ModTower)this).IsValidCrosspath(tiers);
		}
	}
	public class CardMonkeyMod : BloonsTD6Mod
	{
		public static readonly ModSettingHotkey CardMonkeyHotkey = new ModSettingHotkey((KeyCode)119, (HotkeyModifier)1)
		{
			icon = ModContent.GetTextureGUID<CardMonkeyMod>("CardMonkey-Icon")
		};
	}
	public static class ModHelperData
	{
		public const string WorksOnVersion = "54.0";

		public const string Version = "1.2.19";

		public const string Name = "Card Monkey";

		public const string Description = "Adds in a new custom tower themed around playing cards.";

		public const string RepoOwner = "doombubbles";

		public const string PrevRepoName = "card-monkey";

		public const string RepoName = "CardMonkey";

		public const string Icon = "CardMonkey-Icon.png";
	}
}
namespace CardMonkey.Upgrades
{
	public class GodKingOfSpades : ModParagonUpgrade<CardMonkey>
	{
		public override int Cost => 400000;

		public override string Description => "Sometimes the hand of fate must be forced...";

		public override string DisplayName => "God-King of Spades";

		public override void ApplyUpgrade(TowerModel towerModel)
		{
		}
	}
}
namespace CardMonkey.Upgrades.TopPath
{
	public class FourOfAKind : ModUpgrade<CardMonkey>
	{
		public override int Path => 0;

		public override int Tier => 3;

		public override int Cost => 1000;

		public override string DisplayName => "Four of a Kind";

		public override string Description => "Throws four cards at a time";

		public override string Portrait => "CardMonkey-Portrait";

		public override void ApplyUpgrade(TowerModel tower)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			TowerModelExt.GetWeapon(tower).emission = (EmissionModel)new ArcEmissionModel("ArcEmissionModel_", 4, 0f, 20f, (Il2CppReferenceArray<EmissionBehaviorModel>)null, false, false);
		}
	}
	public class Pair : ModUpgrade<CardMonkey>
	{
		public override int Path => 0;

		public override int Tier => 1;

		public override int Cost => 500;

		public override string Description => "Throws two cards at a time";

		public override void ApplyUpgrade(TowerModel tower)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			TowerModelExt.GetWeapon(tower).emission = (EmissionModel)new ArcEmissionModel("ArcEmissionModel_", 2, 0f, 10f, (Il2CppReferenceArray<EmissionBehaviorModel>)null, false, false);
		}
	}
	public class RoyalFlush : ModUpgrade<CardMonkey>
	{
		public override int Path => 0;

		public override int Tier => 5;

		public override int Cost => 20000;

		public override int Priority => -2;

		public override string Description => "Cards do 10, 11, 12, 13 and 14 damage.";

		public override string Portrait => "CardMonkey-Portrait";

		public override void ApplyUpgrade(TowerModel tower)
		{
			tower.range += 10f;
			AttackModel attackModel = TowerModelExt.GetAttackModel(tower);
			attackModel.range += 10f;
			foreach (WeaponModel weapon in TowerModelExt.GetWeapons(tower))
			{
				DamageModel damageModel = ProjectileModelExt.GetDamageModel(weapon.projectile);
				damageModel.damage += 10f;
			}
		}
	}
	public class StraightFlush : ModUpgrade<CardMonkey>
	{
		public override int Path => 0;

		public override int Tier => 4;

		public override int Cost => 4000;

		public override int Priority => -1;

		public override string Description => "Throws 5 cards at a time. Cards do 1, 2, 3, 4 and 5 damage.";

		public override string Portrait => "CardMonkey-Portrait";

		public override void ApplyUpgrade(TowerModel tower)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			foreach (WeaponModel weapon in TowerModelExt.GetWeapons(tower))
			{
				weapon.emission = (EmissionModel)new EmissionWithOffsetsModel("EmissionWithOffsetsModel_", Il2CppReferenceArray<ThrowMarkerOffsetModel>.op_Implicit((ThrowMarkerOffsetModel[])(object)new ThrowMarkerOffsetModel[1]
				{
					new ThrowMarkerOffsetModel("ThrowMarkerOffsetModel_", -4f, 0f, 0f, 0f)
				}), 1, false, (Il2CppReferenceArray<EmissionBehaviorModel>)null, 0f, false);
				for (int i = 1; i <= 4; i++)
				{
					WeaponModel val = ModelExt.Duplicate<WeaponModel>(weapon);
					DamageModel damageModel = ProjectileModelExt.GetDamageModel(val.projectile);
					damageModel.damage += (float)i;
					ThrowMarkerOffsetModel obj = ((Il2CppArrayBase<ThrowMarkerOffsetModel>)(object)((Il2CppObjectBase)val.emission).Cast<EmissionWithOffsetsModel>().throwMarkerOffsetModels)[0];
					obj.ejectX += (float)(i * 2);
					AttackModelExt.AddWeapon(TowerModelExt.GetAttackModel(tower), val);
				}
			}
		}
	}
	public class ThreeOfAKind : ModUpgrade<CardMonkey>
	{
		public override int Path => 0;

		public override int Tier => 2;

		public override int Cost => 700;

		public override string DisplayName => "Three of a Kind";

		public override string Description => "Throws three cards at a time";

		public override string Portrait => "CardMonkey-Portrait";

		public override void ApplyUpgrade(TowerModel tower)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			TowerModelExt.GetWeapon(tower).emission = (EmissionModel)new ArcEmissionModel("ArcEmissionModel_", 3, 0f, 15f, (Il2CppReferenceArray<EmissionBehaviorModel>)null, false, false);
		}
	}
}
namespace CardMonkey.Upgrades.MiddlePath
{
	public class AceInTheHole : ModUpgrade<CardMonkey>
	{
		public override int Path => 1;

		public override int Tier => 4;

		public override int Cost => 4440;

		public override string DisplayName => "Ace in the Hole";

		public override string Description => "Ability: Throws a super powerful Ace card that seeks Bloons along the track.";

		public override string Portrait => "CardMonkey-Portrait";

		public override void ApplyUpgrade(TowerModel tower)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Expected O, but got Unknown
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Expected O, but got Unknown
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Expected O, but got Unknown
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Expected O, but got Unknown
			ActivateAttackModel val = new ActivateAttackModel("ActivateAttackModel_AceInTheHole", 0f, true, new Il2CppReferenceArray<AttackModel>(1L), true, false, false, false, false, false);
			AttackModel val2 = (((Il2CppArrayBase<AttackModel>)(object)val.attacks)[0] = ModelExt.Duplicate<AttackModel>(TowerModelExt.GetAttackModel(Game.instance.model.GetTower(TowerType.BoomerangMonkey, 4, 0, 0))));
			AttackModel val4 = val2;
			((Model)val).AddChildDependant<AttackModel>(val4);
			val4.behaviors = Il2CppReferenceArrayExt.RemoveItemOfType<Model, TargetCloseModel>(Il2CppReferenceArrayExt.RemoveItemOfType<Model, TargetLastModel>(Il2CppReferenceArrayExt.RemoveItemOfType<Model, TargetStrongModel>(Il2CppReferenceArrayExt.RemoveItemOfType<Model, RotateToTargetModel>(val4.behaviors))));
			TargetFirstModel behavior = AttackModelBehaviorExt.GetBehavior<TargetFirstModel>(val4);
			behavior.isSelectable = false;
			val4.targetProvider = (TargetSupplierModel)(object)behavior;
			val4.range = 2000f;
			val4.attackThroughWalls = true;
			WeaponModel val5 = ((Il2CppArrayBase<WeaponModel>)(object)val4.weapons)[0];
			EmissionModelBehaviorExt.AddBehavior<EmissionRotationOffBloonDirectionModel>(val5.emission, new EmissionRotationOffBloonDirectionModel("", false, false));
			ProjectileModel projectile = val5.projectile;
			ProjectileModelExt.ApplyDisplay<AceInTheHoleAbilityDisplay>(projectile);
			projectile.pierce = 1000f;
			ProjectileModelBehaviorExt.RemoveBehavior<RotateModel>(projectile);
			ProjectileModelBehaviorExt.GetBehavior<RetargetOnContactModel>(projectile).distance = 2000f;
			ProjectileModelExt.GetDamageModel(projectile).damage = 20f;
			ProjectileModelExt.GetDamageModel(projectile).immuneBloonProperties = (BloonProperties)0;
			ProjectileModelBehaviorExt.AddBehavior<DamageModifierForTagModel>(projectile, new DamageModifierForTagModel("DamageModifierForTagModel_Ceramic", "Ceramic", 1f, 30f, false, false, false));
			ProjectileModelBehaviorExt.AddBehavior<DamageModifierForTagModel>(projectile, new DamageModifierForTagModel("DamageModifierForTagModel_Fortified", "Fortified", 1f, 30f, false, false, false));
			ProjectileModelBehaviorExt.GetBehavior<TravelStraitModel>(projectile).Speed = 500f;
			ProjectileModelBehaviorExt.GetBehavior<TravelStraitModel>(projectile).Lifespan = 5f;
			projectile.hasDamageModifiers = true;
			AbilityHelper val6 = new AbilityHelper("AceInTheHole");
			val6.DisplayName = "Ace in the Hole";
			val6.Description = "Throws a super powerful Ace card that seeks Bloons along the track.";
			val6.Animation = 1;
			val6.IconReference = ((ModContent)this).GetSpriteReference(((ModUpgrade)this).Icon);
			val6.Cooldown = 44f;
			val6.Behaviors = (Model[])(object)new Model[1] { (Model)val };
			TowerModelBehaviorExt.AddBehavior(tower, (ModelHelper)(object)val6);
		}
	}
	public class AceOfSpades : ModUpgrade<CardMonkey>
	{
		public override int Path => 1;

		public override int Tier => 5;

		public override int Cost => 44440;

		public override int Priority => -3;

		public override string DisplayName => "Ace of Spades";

		public override string Description => "Aces are even more deadly, dealing extreme damage to MOAB class bloons.";

		public override string Portrait => "CardMonkey-Portrait";

		public override void ApplyUpgrade(TowerModel tower)
		{
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Expected O, but got Unknown
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Expected O, but got Unknown
			tower.range += 10f;
			AttackModel attackModel = TowerModelExt.GetAttackModel(tower);
			attackModel.range += 10f;
			foreach (ProjectileModel item in from weaponModel in TowerModelExt.GetWeapons(tower)
				select weaponModel.projectile)
			{
				DamageModel damageModel = ProjectileModelExt.GetDamageModel(item);
				damageModel.damage += 3f;
				foreach (DamageModifierForTagModel behavior in ProjectileModelBehaviorExt.GetBehaviors<DamageModifierForTagModel>(item))
				{
					behavior.damageAddative += 42f;
				}
				ProjectileModelBehaviorExt.AddBehavior<DamageModifierForTagModel>(item, new DamageModifierForTagModel("DamageModifierForTagModel_Moabs", "Moabs", 1f, 45f, false, false, false));
				ProjectileModelExt.ApplyDisplay<AceOfSpadesCardDisplay>(item);
			}
			AbilityModel ability = TowerModelExt.GetAbility(tower);
			ability.resetCooldownOnTierUpgrade = true;
			ability.icon = ((ModContent)this).GetSpriteReference(((ModUpgrade)this).Icon);
			ProjectileModel descendant = ((Model)ability).GetDescendant<ProjectileModel>();
			ProjectileModelExt.ApplyDisplay<AceOfSpadesAbilityDisplay>(descendant);
			ProjectileModelExt.GetDamageModel(descendant).damage = 1000f;
			descendant.pierce = 10000f;
			foreach (DamageModifierForTagModel behavior2 in ProjectileModelBehaviorExt.GetBehaviors<DamageModifierForTagModel>(descendant))
			{
				behavior2.damageAddative = 2000f;
			}
			ProjectileModelBehaviorExt.AddBehavior<DamageModifierForTagModel>(descendant, new DamageModifierForTagModel("DamageModifierForTagModel_Moabs", "Moabs", 1f, 2000f, false, false, false));
			descendant.hasDamageModifiers = true;
		}
	}
	public class AcesWild : ModUpgrade<CardMonkey>
	{
		public override int Path => 1;

		public override int Tier => 3;

		public override int Cost => 1500;

		public override string DisplayName => "Aces Wild";

		public override string Description => "Powerful Ace cards do more damage, further increased against Ceramic and Fortified Bloons.";

		public override string Portrait => "CardMonkey-Portrait";

		public override void ApplyUpgrade(TowerModel tower)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Expected O, but got Unknown
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Expected O, but got Unknown
			foreach (ProjectileModel item in from weaponModel in TowerModelExt.GetWeapons(tower)
				select weaponModel.projectile)
			{
				DamageModel damageModel = ProjectileModelExt.GetDamageModel(item);
				float damage = damageModel.damage;
				damageModel.damage = damage + 1f;
				ProjectileModelBehaviorExt.AddBehavior<DamageModifierForTagModel>(item, new DamageModifierForTagModel("", "Ceramic", 1f, 3f, false, false, false));
				ProjectileModelBehaviorExt.AddBehavior<DamageModifierForTagModel>(item, new DamageModifierForTagModel("", "Fortified", 1f, 3f, false, false, false));
				ProjectileModelExt.ApplyDisplay<WildAceCardDisplay>(item);
				item.hasDamageModifiers = true;
			}
		}
	}
	public class CutTheDeck : ModUpgrade<CardMonkey>
	{
		public override int Path => 1;

		public override int Tier => 1;

		public override int Cost => 400;

		public override string DisplayName => "Cut the Deck";

		public override string Description => "Cards have increased pierce";

		public override string Portrait => "CardMonkey-Portrait";

		public override void ApplyUpgrade(TowerModel tower)
		{
			foreach (WeaponModel weapon in TowerModelExt.GetWeapons(tower))
			{
				if (tower.tier == 5)
				{
					ProjectileModel projectile = weapon.projectile;
					projectile.pierce += 30f;
				}
				else
				{
					ProjectileModel projectile2 = weapon.projectile;
					projectile2.pierce += 3f;
				}
			}
		}
	}
	public class WildCards : ModUpgrade<CardMonkey>
	{
		public override int Path => 1;

		public override int Tier => 2;

		public override int Cost => 1000;

		public override string Description => "Cards can damage all Bloon types";

		public override string Portrait => "CardMonkey-Portrait";

		public override void ApplyUpgrade(TowerModel tower)
		{
			foreach (WeaponModel weapon in TowerModelExt.GetWeapons(tower))
			{
				ProjectileModelExt.GetDamageModel(weapon.projectile).immuneBloonProperties = (BloonProperties)0;
				ProjectileModelExt.ApplyDisplay<RedWildCardDisplay>(weapon.projectile);
			}
		}
	}
}
namespace CardMonkey.Upgrades.BottomPath
{
	public class CardCounting : ModUpgrade<CardMonkey>
	{
		public override int Path => 2;

		public override int Tier => 1;

		public override int Cost => 300;

		public override string Description => "Throws cards faster";

		public override string Portrait => "CardMonkey-Portrait";

		public override void ApplyUpgrade(TowerModel tower)
		{
			foreach (WeaponModel weapon in TowerModelExt.GetWeapons(tower))
			{
				weapon.Rate *= 0.666666f;
			}
		}
	}
	public class MarkedCards : ModUpgrade<CardMonkey>
	{
		public override int Path => 2;

		public override int Tier => 4;

		public override int Cost => 2500;

		public override string Description => "Attacks extra fast permanently and with bigger range";

		public override string Portrait => "CardMonkey-Portrait";

		public override void ApplyUpgrade(TowerModel tower)
		{
			tower.range += 15f;
			AttackModel attackModel = TowerModelExt.GetAttackModel(tower);
			attackModel.range += 15f;
			foreach (WeaponModel weapon in TowerModelExt.GetWeapons(tower))
			{
				weapon.Rate *= 0.5f;
			}
		}
	}
	public class SleightOfHand : ModUpgrade<CardMonkey>
	{
		public override int Path => 2;

		public override int Tier => 2;

		public override int Cost => 350;

		public override string DisplayName => "Sleight of Hand";

		public override string Description => "Can attack Camo Bloons";

		public override string Portrait => "CardMonkey-Portrait";

		public override int Priority => -1;

		public override void ApplyUpgrade(TowerModel tower)
		{
			Il2CppGenericIEnumerable.ForEach<FilterInvisibleModel>(((Model)tower).GetDescendants<FilterInvisibleModel>(), (Action<FilterInvisibleModel>)delegate(FilterInvisibleModel model)
			{
				model.isActive = false;
			});
		}
	}
	public class StackedDeck : ModUpgrade<CardMonkey>
	{
		public override int Path => 2;

		public override int Tier => 3;

		public override int Cost => 750;

		public override string Description => "Attacks extra fast at the start of the round";

		public override string Portrait => "CardMonkey-Portrait";

		public override void ApplyUpgrade(TowerModel tower)
		{
			if (tower.tier == 3)
			{
				StartOfRoundRateBuffModel val = ModelExt.Duplicate<StartOfRoundRateBuffModel>(TowerModelBehaviorExt.GetBehavior<StartOfRoundRateBuffModel>(Game.instance.model.GetTower(TowerType.SpikeFactory, 0, 0, 2)));
				val.modifier = 0.5f;
				val.duration = 10f;
				TowerModelBehaviorExt.AddBehavior<StartOfRoundRateBuffModel>(tower, val);
			}
		}
	}
	public class TwistOfFate : ModUpgrade<CardMonkey>
	{
		public override int Path => 2;

		public override int Tier => 5;

		public override int Cost => 50000;

		public override string DisplayName => "Twist of Fate";

		public override string Description => "Cards can explode, stun Bloons, and make Bloons give extra money.";

		public override string Portrait => "CardMonkey-Portrait";

		public override void ApplyUpgrade(TowerModel tower)
		{
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Expected O, but got Unknown
			//IL_0270: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Expected O, but got Unknown
			//IL_028f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a7: Expected O, but got Unknown
			//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a9: Expected O, but got Unknown
			tower.range += 10f;
			AttackModel attackModel = TowerModelExt.GetAttackModel(tower);
			attackModel.range += 10f;
			WeaponModel weapon = TowerModelExt.GetWeapon(tower);
			WeaponModel val = ModelExt.Duplicate<WeaponModel>(weapon);
			((Model)val).name = "WeaponModel_GoldCard";
			TowerModel tower2 = Game.instance.model.GetTower(TowerType.Alchemist, 0, 0, 4);
			IncreaseBloonWorthModel val2 = ModelExt.Duplicate<IncreaseBloonWorthModel>(((Model)TowerModelExt.GetAttackModels(tower2)[1]).GetDescendant<IncreaseBloonWorthModel>());
			FilterOutTagModel filter = ModelExt.Duplicate<FilterOutTagModel>(((Model)tower2).GetDescendant<FilterOutTagModel>());
			val2.filter = (FilterModel)(object)filter;
			val.projectile.collisionPasses = Il2CppStructArray<int>.op_Implicit(new int[2] { -1, 0 });
			ProjectileModelBehaviorExt.AddBehavior<IncreaseBloonWorthModel>(val.projectile, val2);
			if (((Il2CppArrayBase<string>)(object)tower.appliedUpgrades).Contains(ModContent.UpgradeID<WildCards>()))
			{
				ProjectileModelExt.ApplyDisplay<GoldWildCardDisplay>(val.projectile);
			}
			else
			{
				ProjectileModelExt.ApplyDisplay<GoldCardDisplay>(val.projectile);
			}
			AttackModelExt.AddWeapon(TowerModelExt.GetAttackModel(tower), val);
			WeaponModel val3 = ModelExt.Duplicate<WeaponModel>(weapon);
			((Model)val3).name = "WeaponModel_Blue_card";
			TowerModel tower3 = Game.instance.model.GetTower(TowerType.BombShooter, 4, 0, 0);
			SlowModel val4 = ModelExt.Duplicate<SlowModel>(((Model)tower3).GetDescendant<SlowModel>());
			SlowModifierForTagModel val5 = ModelExt.Duplicate<SlowModifierForTagModel>(((Model)tower3).GetDescendant<SlowModifierForTagModel>());
			val3.projectile.collisionPasses = Il2CppStructArray<int>.op_Implicit(new int[2] { -1, 0 });
			ProjectileModelBehaviorExt.AddBehavior<SlowModel>(val3.projectile, val4);
			ProjectileModelBehaviorExt.AddBehavior<SlowModifierForTagModel>(val3.projectile, val5);
			if (((Il2CppArrayBase<string>)(object)tower.appliedUpgrades).Contains(ModContent.UpgradeID<WildCards>()))
			{
				ProjectileModelExt.ApplyDisplay<BlueWildCardDisplay>(val3.projectile);
			}
			else
			{
				ProjectileModelExt.ApplyDisplay<BlueCardDisplay>(val3.projectile);
			}
			val3.Rate *= 1.2f;
			AttackModelExt.AddWeapon(TowerModelExt.GetAttackModel(tower), val3);
			ProjectileModel val6 = ModelExt.Duplicate<ProjectileModel>(TowerModelExt.GetWeapon(Game.instance.model.GetTower(TowerType.BombShooter, 3, 0, 0)).projectile);
			CreateProjectileOnContactModel behavior = ProjectileModelBehaviorExt.GetBehavior<CreateProjectileOnContactModel>(val6);
			CreateSoundOnProjectileCollisionModel behavior2 = ProjectileModelBehaviorExt.GetBehavior<CreateSoundOnProjectileCollisionModel>(val6);
			CreateEffectOnContactModel behavior3 = ProjectileModelBehaviorExt.GetBehavior<CreateEffectOnContactModel>(val6);
			CreateProjectileOnExhaustFractionModel val7 = new CreateProjectileOnExhaustFractionModel("CreateProjectileOnExhaustFractionModel_", behavior.projectile, behavior.emission, 1f, 1f, true, false, false);
			ProjectileModelBehaviorExt.AddBehavior<CreateProjectileOnExhaustFractionModel>(weapon.projectile, val7);
			CreateSoundOnProjectileExhaustModel val8 = new CreateSoundOnProjectileExhaustModel("CreateSoundOnProjectileExhaustModel_", behavior2.sound1, behavior2.sound2, behavior2.sound3, behavior2.sound4, behavior2.sound5);
			ProjectileModelBehaviorExt.AddBehavior<CreateSoundOnProjectileExhaustModel>(weapon.projectile, val8);
			CreateEffectOnExhaustedModel val9 = new CreateEffectOnExhaustedModel("CreateEffectOnExhaustedModel_", new PrefabReference(""), 0f, (Fullscreen)0, false, behavior3.effectModel);
			ProjectileModelBehaviorExt.AddBehavior<CreateEffectOnExhaustedModel>(weapon.projectile, val9);
			weapon.Rate *= 0.8f;
		}
	}
}
namespace CardMonkey.Displays
{
	public class CardMonkeyBaseDisplay : ModTowerDisplay<CardMonkey>
	{
		public override string BaseDisplay => ((ModDisplay)this).GetDisplay(TowerType.BoomerangMonkey, 0, 0, 0);

		public override bool UseForTower(params int[] tiers)
		{
			return tiers.Sum() == 0;
		}

		public override void ModifyDisplayNode(UnityDisplayNode node)
		{
			//IL_0012: 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)
			((ModDisplay)this).SetMeshOutlineColor(node, new Color(0.28627452f, 35f / 51f, 0.20392157f));
			RendererExt.AdjustHSV(UnityDisplayNodeExt.GetRenderer(node, "FlatSkin", true), 56f, 0.3f, 0.9f, (Color?)new Color(1f, 0.95686275f, 0f), 0.4f);
			UnityDisplayNodeExt.RemoveBone(node, "SuperMonkeyRig:Dart", false);
		}
	}
	public class CardMonkeyMultiDisplay : ModTowerDisplay<CardMonkey>
	{
		private readonly int[] t = Array.Empty<int>();

		public override string Name => "CardMonkeyMultiDisplay-" + ArrayExt.Printed(t);

		public override string BaseDisplay => ((ModDisplay)this).GetDisplay(TowerType.BoomerangMonkey, t[0], t[1], t[2]);

		public CardMonkeyMultiDisplay()
		{
		}

		public CardMonkeyMultiDisplay(int[] tiers)
		{
			t = tiers;
		}

		public override IEnumerable<ModContent> Load()
		{
			for (int i = 0; i <= 2; i++)
			{
				for (int j = 0; j <= 2; j++)
				{
					for (int k = 0; k <= 2; k++)
					{
						int[] tiers = new int[3] { i, j, k };
						if (ArrayExt.IsValid(tiers))
						{
							yield return (ModContent)(object)new CardMonkeyMultiDisplay(tiers);
						}
					}
				}
			}
		}

		public override bool UseForTower(params int[] tiers)
		{
			if (t.Sum() == 0)
			{
				return tiers.Max() < 5;
			}
			return false;
		}

		public override void ModifyDisplayNode(UnityDisplayNode node)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			RendererExt.AdjustHSV(UnityDisplayNodeExt.GetRenderer(node, "FlatSkin", true), 56f, 0.3f, 0.9f, (Color?)new Color(1f, 0.95686275f, 0f), 0.4f);
			((ModDisplay)this).SetMeshOutlineColor(node, new Color(0.28627452f, 35f / 51f, 0.20392157f));
			UnityDisplayNodeExt.RemoveBone(node, "SuperMonkeyRig:Dart", false);
		}
	}
	public class CardMonkeyParagonDisplay : ModTowerDisplay<CardMonkey>
	{
		public override float Scale => 0.75f + (float)((ModTowerDisplay)this).ParagonDisplayIndex * 0.025f;

		public override string BaseDisplay => AttackModelBehaviorExt.GetBehavior<DisplayModel>(TowerModelExt.GetAttackModel(Game.instance.model.GetTower(TowerType.SuperMonkey, 5, 0, 0))).display.AssetGUID;

		public override int ParagonDisplayIndex { get; }

		public override string Name => "CardMonkeyParagonDisplay" + ((ModTowerDisplay)this).ParagonDisplayIndex;

		public CardMonkeyParagonDisplay()
		{
		}

		public CardMonkeyParagonDisplay(int i)
		{
			ParagonDisplayIndex = i;
		}

		public override bool UseForTower(params int[] tiers)
		{
			return ((ModTowerDisplay)this).IsParagon(tiers);
		}

		public override IEnumerable<ModContent> Load()
		{
			for (int i = 0; i < 5; i++)
			{
				yield return (ModContent)(object)new CardMonkeyParagonDisplay(i);
			}
		}

		public override void ModifyDisplayNode(UnityDisplayNode node)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			((ModDisplay)this).SetMeshTexture(node, "CardMonkeyParagonDisplay");
			((ModDisplay)this).SetMeshOutlineColor(node, new Color(16f / 85f, 0f, 0.4745098f));
		}
	}
}
namespace CardMonkey.Displays.Tier5
{
	public class AceOfSpadesDisplay : ModTowerDisplay<CardMonkey>
	{
		public override string BaseDisplay => ((ModDisplay)this).GetDisplay(TowerType.BoomerangMonkey, 5, 0, 0);

		public override bool UseForTower(params int[] tiers)
		{
			return tiers[1] == 5;
		}

		public override void ModifyDisplayNode(UnityDisplayNode node)
		{
			//IL_002d: 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)
			UnityDisplayNodeExt.RemoveBone(node, "SuperMonkeyRig:Dart", false);
			((ModDisplay)this).SetMeshTexture(node, "AceOfSpadesCape", 1);
			((ModDisplay)this).SetMeshOutlineColor(node, new Color(0f, 0f, 0f), 1);
			((ModDisplay)this).SetMeshTexture(node, "AceOfSpadesDisplay", 2);
			((ModDisplay)this).SetMeshOutlineColor(node, new Color(0f, 0f, 0f), 2);
		}
	}
	public class RoyalFlushDisplay : ModTowerDisplay<CardMonkey>
	{
		public override string BaseDisplay => ((ModDisplay)this).GetDisplay(TowerType.Alchemist, 0, 0, 5);

		public override bool UseForTower(params int[] tiers)
		{
			return tiers[0] == 5;
		}

		public override void ModifyDisplayNode(UnityDisplayNode node)
		{
			//IL_002d: 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)
			UnityDisplayNodeExt.RemoveBone(node, "AlchemistRig:Propjectile_R", false);
			((ModDisplay)this).SetMeshTexture(node, "RoyalFlushDisplay", 0);
			((ModDisplay)this).SetMeshOutlineColor(node, new Color(0.28627452f, 35f / 51f, 0.20392157f), 0);
			((ModDisplay)this).SetMeshTexture(node, "RoyalFlushDisplay", 1);
			((ModDisplay)this).SetMeshOutlineColor(node, new Color(0.28627452f, 35f / 51f, 0.20392157f), 1);
		}
	}
	public class TFDisplay : ModTowerDisplay<CardMonkey>
	{
		public override string BaseDisplay => ((ModDisplay)this).GetDisplay(TowerType.BoomerangMonkey, 0, 0, 4);

		public override float Scale => 1.15f;

		public override bool UseForTower(params int[] tiers)
		{
			return tiers[2] == 5;
		}

		public override void ModifyDisplayNode(UnityDisplayNode node)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			UnityDisplayNodeExt.RemoveBone(node, "SuperMonkeyRig:Dart", false);
			((ModDisplay)this).SetMeshTexture(node, ((ModContent)this).Name, 1);
			((ModDisplay)this).SetMeshOutlineColor(node, new Color(0.28627452f, 35f / 51f, 0.20392157f), 1);
		}
	}
}
namespace CardMonkey.Displays.Projectiles
{
	public class RedCardDisplay : ModDisplay
	{
		public override string BaseDisplay => "9dccc16d26c1c8a45b129e2a8cbd17ba";

		public override void ModifyDisplayNode(UnityDisplayNode node)
		{
			((ModDisplay)this).Set2DTexture(node, ((ModContent)this).Name);
		}
	}
	public class BlueCardDisplay : ModDisplay
	{
		public override string BaseDisplay => "9dccc16d26c1c8a45b129e2a8cbd17ba";

		public override void ModifyDisplayNode(UnityDisplayNode node)
		{
			((ModDisplay)this).Set2DTexture(node, ((ModContent)this).Name);
		}
	}
	public class GoldCardDisplay : ModDisplay
	{
		public override string BaseDisplay => "9dccc16d26c1c8a45b129e2a8cbd17ba";

		public override void ModifyDisplayNode(UnityDisplayNode node)
		{
			((ModDisplay)this).Set2DTexture(node, ((ModContent)this).Name);
		}
	}
	public class RedWildCardDisplay : ModDisplay
	{
		public override string BaseDisplay => "9dccc16d26c1c8a45b129e2a8cbd17ba";

		public override void ModifyDisplayNode(UnityDisplayNode node)
		{
			((ModDisplay)this).Set2DTexture(node, ((ModContent)this).Name);
		}
	}
	public class GoldWildCardDisplay : ModDisplay
	{
		public override string BaseDisplay => "9dccc16d26c1c8a45b129e2a8cbd17ba";

		public override void ModifyDisplayNode(UnityDisplayNode node)
		{
			((ModDisplay)this).Set2DTexture(node, ((ModContent)this).Name);
		}
	}
	public class BlueWildCardDisplay : ModDisplay
	{
		public override string BaseDisplay => "9dccc16d26c1c8a45b129e2a8cbd17ba";

		public override void ModifyDisplayNode(UnityDisplayNode node)
		{
			((ModDisplay)this).Set2DTexture(node, ((ModContent)this).Name);
		}
	}
	public class WildAceCardDisplay : ModDisplay
	{
		public override string BaseDisplay => "9dccc16d26c1c8a45b129e2a8cbd17ba";

		public override void ModifyDisplayNode(UnityDisplayNode node)
		{
			((ModDisplay)this).Set2DTexture(node, ((ModContent)this).Name);
		}
	}
	public class AceInTheHoleAbilityDisplay : ModDisplay
	{
		public override string BaseDisplay => "9dccc16d26c1c8a45b129e2a8cbd17ba";

		public override float Scale => 2f;

		public override Vector3 PositionOffset => new Vector3(0f, 5f, 0f);

		public override void ModifyDisplayNode(UnityDisplayNode node)
		{
			((ModDisplay)this).Set2DTexture(node, "WildAceCardDisplay");
		}
	}
	public class AceOfSpadesCardDisplay : ModDisplay
	{
		public override string BaseDisplay => "9dccc16d26c1c8a45b129e2a8cbd17ba";

		public override void ModifyDisplayNode(UnityDisplayNode node)
		{
			((ModDisplay)this).Set2DTexture(node, ((ModContent)this).Name);
		}
	}
	public class AceOfSpadesAbilityDisplay : ModDisplay
	{
		public override string BaseDisplay => "9dccc16d26c1c8a45b129e2a8cbd17ba";

		public override float Scale => 2f;

		public override Vector3 PositionOffset => new Vector3(0f, 5f, 0f);

		public override void ModifyDisplayNode(UnityDisplayNode node)
		{
			((ModDisplay)this).Set2DTexture(node, "AceOfSpadesCardDisplay");
		}
	}
}