MainFile.cs

using AutoPlay.Config;
using Godot;
using HarmonyLib;
using MegaCrit.Sts2.Core.CardSelection;
using MegaCrit.Sts2.Core.Combat;
using MegaCrit.Sts2.Core.Combat.History.Entries;
using MegaCrit.Sts2.Core.Commands;
using MegaCrit.Sts2.Core.Context;
using MegaCrit.Sts2.Core.Entities.Cards;
using MegaCrit.Sts2.Core.Entities.Creatures;
using MegaCrit.Sts2.Core.Entities.Players;
using MegaCrit.Sts2.Core.Entities.Potions;
using MegaCrit.Sts2.Core.Extensions;
using MegaCrit.Sts2.Core.GameActions;
using MegaCrit.Sts2.Core.GameActions.Multiplayer;
using MegaCrit.Sts2.Core.Hooks;
using MegaCrit.Sts2.Core.Logging;
using MegaCrit.Sts2.Core.Modding;
using MegaCrit.Sts2.Core.Models;
using MegaCrit.Sts2.Core.Models.Cards;
using MegaCrit.Sts2.Core.Models.Monsters;
using MegaCrit.Sts2.Core.Models.Potions;
using MegaCrit.Sts2.Core.Models.Powers;
using MegaCrit.Sts2.Core.Models.Relics;
using MegaCrit.Sts2.Core.MonsterMoves.Intents;
using MegaCrit.Sts2.Core.Nodes.Cards.Holders;
using MegaCrit.Sts2.Core.Nodes.Combat;
using MegaCrit.Sts2.Core.Nodes.Debug;
using MegaCrit.Sts2.Core.Nodes.Potions;
using MegaCrit.Sts2.Core.Nodes.Rooms;
using MegaCrit.Sts2.Core.Rooms;
using MegaCrit.Sts2.Core.Runs;
using System.Reflection;
using System.Text.Json;
using Logger = MegaCrit.Sts2.Core.Logging.Logger;

namespace AutoPlay;

public static class ModSettings
{
	public static bool AutomaticDiscard { get; set; } = true;
	public static bool AutomaticExhaust { get; set; } = true;
	public static bool AutomaticSelect { get; set; } = true;
	public static bool AutomaticRetain { get; set; } = true;
	public static bool HardSelect { get; set; } = true;
}
public class AutoPlayConfigData
{
	public bool AutomaticDiscard { get; set; } = true;
	public bool AutomaticExhaust { get; set; } = true;
	public bool AutomaticSelect { get; set; } = true;
	public bool AutomaticRetain { get; set; } = true;
	public bool HardSelect { get; set; } = true;
}

[ModInitializer(nameof(Initialize))]
public partial class MainFile : Node
{
	private const string ModId = "AutoPlay";

	private static Logger Logger { get; } = new(ModId, LogType.Generic);

	public static void Initialize()
	{
		Harmony harmony = new(ModId);
		harmony.PatchAll();

		if (File.Exists("mods/AutoPlay.json"))
		{
			var json = File.ReadAllText("mods/AutoPlay.json");
			var data = JsonSerializer.Deserialize<AutoPlayConfigData>(json);

			if (data != null)
			{
				ModSettings.AutomaticDiscard = data.AutomaticDiscard;
				ModSettings.AutomaticExhaust = data.AutomaticExhaust;
				ModSettings.AutomaticSelect = data.AutomaticSelect;
				ModSettings.AutomaticRetain = data.AutomaticRetain;
				ModSettings.HardSelect = data.HardSelect;
			}
		}

		ModConfigBridge.DeferredRegister();

		Log("Initialized");
	}

	public static void Log(string message, LogLevel level = LogLevel.Info, int skipFrames = 1)
	{
		Logger.LogMessage(level, $"[{ModId}] {message}", skipFrames);

		try
		{
			var console = NDevConsole.Instance;
			var outputBufferField =
				typeof(NDevConsole).GetField("_outputBuffer", BindingFlags.NonPublic | BindingFlags.Instance);
			if (outputBufferField?.GetValue(console) is not RichTextLabel outputBuffer) return;
			outputBuffer.Text += $"[color=#00ffff][{ModId}][/color] {message}";
			outputBuffer.Text += "\n";
		}
		catch
		{
			// Console might not be initialized yet
		}
	}
}

[HarmonyPatch]
public class Patch
{
	[HarmonyPatch(typeof(NCombatUi), "_Input")]
	[HarmonyPostfix]
	private static void GameInputHook(InputEvent inputEvent)
	{
		if (!ModSettings.HardSelect || inputEvent is not InputEventKey keyEvent || !keyEvent.Pressed || keyEvent.Echo || keyEvent.Keycode != Key.Tab || keyEvent.AltPressed || keyEvent.CtrlPressed || NDevConsole.Instance.Visible) return;

		if (NPlayerHand.Instance?.InCardPlay != false || NTargetManager.Instance.IsInSelection || CombatManager.Instance.IsOverOrEnding || NCombatRoom.Instance == null || ModState.TargettedEnemy == null || ModState.TargettedEnemy.Entity.CombatState == null) return;

		var enemies = ModState.TargettedEnemy.Entity.CombatState.HittableEnemies;
		int index = enemies.IndexOf(ModState.TargettedEnemy.Entity);

		if (index >= 0 && enemies.Count > 0)
		{
			for (int th = 1; th <= enemies.Count; th++)
			{
				int nextIndex = (keyEvent.ShiftPressed ? (index - th + enemies.Count) : (index + th)) % enemies.Count;
				var nextEnemy = enemies[nextIndex];

				if (nextEnemy.IsAlive)
				{
					var enemy_node = NCombatRoom.Instance.GetCreatureNode(nextEnemy);
					if (enemy_node != null)
					{
						ModState.DoNotHideReticle = false;
						ModState.TargettedEnemy.HideSingleSelectReticle();
						ModState.TargettedEnemy = enemy_node;
						ModState.TargettedEnemy.ShowSingleSelectReticle();
						ModState.DoNotHideReticle = true;
					}
					break;
				}
			}
		}
	}

	[HarmonyPatch(typeof(NCreatureVisuals), "_Ready")]
	[HarmonyPostfix]
	private static void NCreatureVisuals_Ready(NCreatureVisuals __instance)
	{
		if (__instance == null) return;

		var parent = __instance.GetParent<NCreature>();

		if (parent?.Hitbox != null && parent.Entity.IsMonster && !parent.Entity.IsPet && parent.Entity.IsAlive)
		{
			parent.Hitbox.GuiInput += (inputEvent) =>
			{
				if ((inputEvent is InputEventMouseButton mouse && mouse.Pressed && !mouse.DoubleClick && mouse.ButtonIndex == MouseButton.Left) || (inputEvent is InputEventScreenTouch touch && touch.Pressed && !touch.DoubleTap))
				{
					if (NTargetManager.Instance.IsInSelection || CombatManager.Instance.IsOverOrEnding || Time.GetTicksMsec() < ModState.IgnoreEnemyClickUntilMs) return;

					if (ModState.DoNotHideReticle != true)
					{
						ModState.TargettedEnemy?.HideSingleSelectReticle();
						parent.ShowSingleSelectReticle();
						ModState.DoNotHideReticle = true;
						ModState.TargettedEnemy = parent;
					}
					else
					{
						ModState.DoNotHideReticle = false;
						ModState.TargettedEnemy?.HideSingleSelectReticle();
						if (parent != ModState.TargettedEnemy)
						{
							parent.ShowSingleSelectReticle();
							ModState.DoNotHideReticle = true;
							ModState.TargettedEnemy = parent;
						}
						else
						{
							ModState.TargettedEnemy = null;
						}
					}
				}
			};
		}
	}

	[HarmonyPatch(typeof(NCombatRoom), nameof(NCombatRoom._Ready))]
	[HarmonyPostfix]
	private static void CombatRoomEnter(NCombatRoom __instance)
	{
		if (__instance != null && __instance.Mode == CombatRoomMode.ActiveCombat && ModState.TargettedEnemy != null)
		{
			ModState.DoNotHideReticle = false;
			ModState.TargettedEnemy.HideSingleSelectReticle();
			ModState.TargettedEnemy = null;
		}
	}

	[HarmonyPatch(typeof(NCreature), nameof(NCreature.HideSingleSelectReticle))]
	[HarmonyPrefix]
	private static bool HideSingleSelectReticle(NCreature __instance)
	{
		return !ModSettings.HardSelect || ModState.TargettedEnemy != __instance || !ModState.DoNotHideReticle;
	}

	[HarmonyPatch(typeof(NCreature), "StartDeathAnim")]
	[HarmonyPostfix]
	private static void CreatureStartDeathAnim(NCreature __instance)
	{
		if (ModState.TargettedEnemy != null && ModState.TargettedEnemy == __instance)
		{
			ModState.DoNotHideReticle = false;
			ModState.TargettedEnemy.HideSingleSelectReticle();
			ModState.TargettedEnemy = null;
		}
	}

	[HarmonyPrefix]
	[HarmonyPatch(typeof(NMouseCardPlay), "TargetSelection")]
	private static bool TargetSelection(NMouseCardPlay __instance, ref Task __result)
	{
		var card = AccessTools.PropertyGetter(typeof(NCardPlay), "Card")?.Invoke(__instance, null) as CardModel;

		if (card == null) return true;

		if (!IsAutoPlayable(card)) return true;

		// manually set _target if type == AnyEnemy
		if (card is { TargetType: TargetType.AnyEnemy })
		{
			var target = card.CombatState?.HittableEnemies[0];
			if (target is null) return true;
			else if(ModSettings.HardSelect && ModState.TargettedEnemy != null && !ModState.TargettedEnemy.Entity.IsDead)
			{
				target = ModState.TargettedEnemy.Entity;
			}

			AccessTools.Field(typeof(NMouseCardPlay), "_target").SetValue(__instance, target);
		}

		// MegaCrit sets _target for All other types in IsAutoPlayable()
		__result = Task.CompletedTask;
		return false;
	}

	[HarmonyPrefix]
	[HarmonyPatch(typeof(NControllerCardPlay), "Start")]
	private static bool TargetSelection_Controller(NControllerCardPlay __instance)
	{
		var card = AccessTools.PropertyGetter(typeof(NCardPlay), "Card")?.Invoke(__instance, null) as CardModel;

		if (__instance.Holder?.CardNode == null || !IsAutoPlayable(card)) return true;

		if (card is { TargetType: TargetType.AnyEnemy })
		{
			var target = card.CombatState?.HittableEnemies[0];
			if (target is null) return true;
			else if (ModSettings.HardSelect && ModState.TargettedEnemy != null && !ModState.TargettedEnemy.Entity.IsDead)
			{
				target = ModState.TargettedEnemy.Entity;
			}

			AccessTools.Method(typeof(NCardPlay), "TryShowEvokingOrbs")?.Invoke(__instance, null);
			__instance.Holder.CardNode.CardHighlight.AnimFlash();
			AccessTools.Method(typeof(NCardPlay), "TryPlayCard")?.Invoke(__instance, [target]);
			return false;
		}

		return false;
	}

	[HarmonyPrefix]
	[HarmonyPatch(typeof(NMouseCardPlay), "IsCardInPlayZone")]
	private static bool IsCardInPlayZone(ref bool __result)
	{
		__result = true;
		return false;
	}

	[HarmonyPatch(typeof(NPlayerHand), "StartCardPlay")]
	private static void StartCardPlay(NHandCardHolder holder, ref bool startedViaShortcut)
	{
		if (IsAutoPlayable(holder.CardModel)) startedViaShortcut = true;
	}

	[HarmonyPatch(typeof(NHandCardHolder), "OnFocus")]
	[HarmonyPostfix]
	private static void CardOnFocus(NHandCardHolder __instance)
	{
		if (__instance == null || __instance.CardModel == null || __instance?.CardModel.CombatState == null || __instance.CardModel.CombatState.HittableEnemies.Count == 0) return;
 
		if ((__instance.CardModel.TargetType == TargetType.AnyEnemy && IsAutoPlayable(__instance.CardModel)) || (__instance.CardModel.TargetType == TargetType.AllEnemies || __instance.CardModel.TargetType == TargetType.RandomEnemy && __instance.CardModel.CombatState.HittableEnemies.Count(enemy => enemy.IsAlive) == 1))
		{
			var target = __instance.CardModel.CombatState.HittableEnemies[0];
			if (target is null) return;
			else if (ModSettings.HardSelect && ModState.TargettedEnemy != null && !ModState.TargettedEnemy.Entity.IsDead)
			{
				target = ModState.TargettedEnemy.Entity;
			}

			__instance.CardNode?.SetPreviewTarget(target);
		}
		else if(__instance.CardModel.TargetType == TargetType.AnyEnemy || __instance.CardModel.TargetType == TargetType.AllEnemies || __instance.CardModel.TargetType == TargetType.RandomEnemy)
		{
			int num_enemies = 0, num_enemies_with_same_damage_modifiers = 0;
			Creature? first = null;
			bool is_vulnerable = false, is_debilitated = false, is_fluttery = false, is_slippery = false;
			int hardtokill_amount = 0, Hardenedshell_amount = 99;
			foreach (Creature enemy in __instance.CardModel.CombatState.HittableEnemies)
			{ 
				if(enemy.IsAlive)
				{
					num_enemies++;
					if (enemy.HasPower<VulnerablePower>() || enemy.HasPower<HardToKillPower>() || enemy.HasPower<FlutterPower>() || enemy.HasPower<SlipperyPower>() || enemy.HasPower<HardenedShellPower>())
					{						
						if (first == null)
						{
							first = enemy;
							num_enemies_with_same_damage_modifiers++;
							is_vulnerable = enemy.HasPower<VulnerablePower>();
							is_debilitated = enemy.HasPower<DebilitatePower>();
							hardtokill_amount = enemy.GetPowerAmount<HardToKillPower>();
							Hardenedshell_amount = 99;
							var hardenedShell = enemy.GetPower<HardenedShellPower>();
							if (hardenedShell != null)
							{
								Hardenedshell_amount = hardenedShell.DisplayAmount;
							}
							is_fluttery = enemy.HasPower<FlutterPower>();
							is_slippery = enemy.HasPower<SlipperyPower>();
						}
						else if(enemy.HasPower<SlipperyPower>() == is_slippery && enemy.HasPower<VulnerablePower>() == is_vulnerable && enemy.GetPowerAmount<HardToKillPower>() == hardtokill_amount && enemy.HasPower<FlutterPower>() == is_fluttery && (enemy.GetPower<HardenedShellPower>()?.DisplayAmount ?? 99) == Hardenedshell_amount && (!is_vulnerable || is_debilitated == enemy.HasPower<SlipperyPower>()))
						{
							num_enemies_with_same_damage_modifiers++;
						}						
					}
				}
			}

			if (num_enemies_with_same_damage_modifiers > 0 && num_enemies_with_same_damage_modifiers == num_enemies)
			{
				__instance.CardNode?.SetPreviewTarget(first);
			}
			else
			{
				__instance?.CardNode?.SetPreviewTarget(null);
			}
		}
	}

	[HarmonyPrefix]
	[HarmonyPatch(typeof(NPotionHolder), "OnRelease")]
	private static bool OnPotionClicked(NPotionHolder __instance)
	{
		if (__instance?.Potion?.Model.Owner.Creature.CombatState == null || CombatManager.Instance.IsOverOrEnding) return true;

		var isUsable_field = AccessTools.Field(typeof(NPotionHolder), "_isUsable");

		var isUsable_value = isUsable_field.GetValue(__instance);

		if (isUsable_value == null || (bool)isUsable_value == false) return true;

		if (__instance.Potion.Model.Usage != PotionUsage.Automatic && __instance.Potion.Model.Id.Entry != "FOUL_POTION")//automatically use every potion except Foul Potion when clicked at them in combat since there is no reason to discard
		{
			__instance.UsePotion();
			return false;
		}
		return true;
	}

	[HarmonyPrefix]
	[HarmonyPatch(typeof(NPotionHolder), "UsePotion")]
	private static bool UsePotion(NPotionHolder __instance, ref Task __result)
	{
		PotionModel? potion = __instance.Potion?.Model;
		if (potion == null || potion.Usage == PotionUsage.Automatic) return true;

		if (!IsAutoPlayable(potion)) return true;

		var target = potion.Owner.Creature.CombatState?.HittableEnemies[0];
		if (target is null) return true;
		else if (ModSettings.HardSelect && ModState.TargettedEnemy != null && !ModState.TargettedEnemy.Entity.IsDead)
		{
			target = ModState.TargettedEnemy.Entity;
		}

		potion.EnqueueManualUse(target);

		__result = Task.CompletedTask;
		return false;
	}

	[HarmonyPrefix]
	[HarmonyPatch(typeof(WellLaidPlansPower), "BeforeFlushLate")]
	private static bool BeforeFlushLate(WellLaidPlansPower __instance, PlayerChoiceContext choiceContext, Player player, ref Task __result)
	{
		if (!ModSettings.AutomaticRetain) return true;
		if (player != __instance.Owner.Player) return true;

		CardPile handPile = PileType.Hand.GetPile(__instance.Owner.Player);

		if (handPile.Cards.Count == 0) return true;
		else if (handPile.Cards.Count <= __instance.Amount)//if the number of remaining cards is same or lower than required amount to choose, choose them all automatically, unless they are unplayable
		{
			foreach (CardModel item in handPile.Cards)
			{
				if ((item.Type <= CardType.Power || item is FranticEscape) && !item.Keywords.Contains(CardKeyword.Retain) && !item.Keywords.Contains(CardKeyword.Ethereal))
				{
					item.GiveSingleTurnRetain();
				}
			}

			__result = Task.CompletedTask;
			return false;
		}

		CardModel first = handPile.Cards[0];

		for (int th = 0; th < handPile.Cards.Count; th++)
		{
			if (!CardsEqual(first, handPile.Cards[th]))
			{
				return true;
			}
		}

		//if all remaining cards are identical, it will retain required amount automatically

		int num_to_retain = __instance.Amount;

		for (int th = 0; th < handPile.Cards.Count && num_to_retain > 0; th++)
		{
			CardModel card = handPile.Cards[th];
			if ((card.Type <= CardType.Power || card is FranticEscape) && !card.Keywords.Contains(CardKeyword.Retain) && !card.Keywords.Contains(CardKeyword.Ethereal))
			{
				card.GiveSingleTurnRetain();
				num_to_retain--;
			}
		}

		__result = Task.CompletedTask;
		return false;
	}

	[HarmonyPatch(typeof(CardModel), nameof(CardModel.OnPlayWrapper))]
	[HarmonyPostfix]
	private static void AfterCardPlayed(CardModel __instance, ref Task __result)
	{
		if (ModState.IgnoreCardPlay) return;
		else if(NPlayerHand.Instance?.InCardPlay == true)
		{
			ModState.IgnoreCardPlay = true;
		}
		__result = AfterCardPlayedFinished(__result, __instance, NPlayerHand.Instance?.InCardPlay == true);
	}

	private static async Task AfterCardPlayedFinished(Task originalTask, CardModel __instance, bool cancel_cardplay_ignore)
	{
		ModState.IgnoreEnemyClickUntilMs = Time.GetTicksMsec() + 250;
		await originalTask;

		if (cancel_cardplay_ignore)
		{
			ModState.IgnoreCardPlay = false;
		}

		if (CombatManager.Instance.IsPlayPhase)
		{
			AutomaticEndTurn(__instance.Owner);
		}
	}

	[HarmonyPatch(typeof(Hook), nameof(Hook.AfterPotionUsed))]
	[HarmonyPostfix]
	private static void AfterPotionUsed(PotionModel potion)
	{
		AutomaticEndTurn(potion.Owner);
	}

	[HarmonyPatch(typeof(Hook), nameof(Hook.AfterPotionDiscarded))]
	[HarmonyPostfix]
	private static void AfterPotionDiscarded(PotionModel potion)
	{
		if (CombatManager.Instance.IsPlayPhase)
		{
			AutomaticEndTurn(potion.Owner);
		}
	}

	[HarmonyPatch(typeof(Hook), nameof(Hook.BeforePlayPhaseStart))]
	[HarmonyPostfix]	
	private static void BeforePlayPhaseStart(CombatState combatState, Player player, ref Task __result)
	{
		__result = BeforePlayPhaseFinished(__result, combatState, player);
	}

	private static async Task BeforePlayPhaseFinished(Task originalTask, CombatState combatState, Player player)
	{
		await originalTask;
		if (combatState.RoundNumber > 0 && LocalContext.NetId == player.NetId)
		{
			var relicPaelsEye = player.Relics.FirstOrDefault(relic => relic is PaelsEye);
			if (relicPaelsEye != null)
			{
				var field = AccessTools.Field(typeof(PaelsEye), "_usedThisCombat");
				var usedThisCombat = field.GetValue(relicPaelsEye);
				if (usedThisCombat == null || (bool)usedThisCombat == false) return;
			}

			if (player.Relics.Any(relic => relic is PenNib or Nunchaku or TuningFork or IronClub or GalacticDust))//only end turn automatically if there are no card counting relics
			{
				return;
			}

			CardPile handPile = PileType.Hand.GetPile(player);
			CardPile drawPile = PileType.Draw.GetPile(player);
			CardPile discardPile = PileType.Discard.GetPile(player);
			var all_reachable_cards = handPile.Cards.Concat(drawPile.Cards).Concat(discardPile.Cards);

			if (all_reachable_cards.Any(card => card is Feed or TheHunt or HandOfGreed or Alchemize or NotYet && player.Creature.CurrentHp < player.Creature.MaxHp))
			{
				return;
			}

			int num_enemies_survive_this_turn = 0, num_minions_survive_this_turn = 0;

			int damage_from_bomb = 0;

			IReadOnlyList<Creature> allies = combatState.PlayerCreatures;
			for (int th = 0; th < allies.Count; th++)
			{
				Creature ally = allies[th];
				var bombPower = ally.GetPower<TheBombPower>();
				if (bombPower != null && bombPower.Amount == 1)
				{
					damage_from_bomb += bombPower.DynamicVars.Damage.IntValue;
				}
			}
			IReadOnlyList<Creature> enemies = combatState.Enemies;
			for (int th = 0; th < enemies.Count; th++)
			{
				Creature enemy = enemies[th];

				if (enemy.Monster?.Id.Entry == "DOOR") return;

				int damage_from_poison = (enemy.GetPower<PoisonPower>()?.CalculateTotalDamageNextTurn() ?? 0);

				if (enemy.IsAlive && (enemy.GetPowerAmount<StockPower>() > 0 || enemy.GetPowerAmount<SurprisePower>() > 0 || enemy.GetPowerAmount<InfestedPower>() > 0 || enemy.GetPowerAmount<SteamEruptionPower>() > 0 || enemy.GetPowerAmount<AdaptablePower>() > 0 || damage_from_poison + damage_from_bomb < enemy.CurrentHp))
				{
					num_enemies_survive_this_turn++;
					if (enemy.HasPower<MinionPower>())
					{
						num_minions_survive_this_turn++;
					}
				}
			}

			if (num_enemies_survive_this_turn == 0 || num_enemies_survive_this_turn == num_minions_survive_this_turn)//no enemies will survive after turn started
			{
				int num_damage_received = 0;

				for (int th = 0; th < handPile.Cards.Count; th++)
				{
					CardModel card = handPile.Cards[th];
					if (card.Type > CardType.Power)
					{
						if (card.DynamicVars.ContainsKey("Damage"))
						{
							num_damage_received += card.DynamicVars.Damage.IntValue;
						}
						else if (card.DynamicVars.ContainsKey("HpLoss"))
						{
							num_damage_received += card.DynamicVars.HpLoss.IntValue;
						}
					}
				}

				num_damage_received += player.Creature.GetPowerAmount<DisintegrationPower>() + player.Creature.GetPowerAmount<ConstrictPower>();

				int player_block = player.Creature.Block;
				if (player_block == 0)
				{
					var relicOrichalcum = player.Relics.FirstOrDefault(relic => relic is Orichalcum);
					if (relicOrichalcum != null)
					{
						player_block += relicOrichalcum.DynamicVars.Block.IntValue;
					}
					relicOrichalcum = player.Relics.FirstOrDefault(relic => relic is FakeOrichalcum);
					if (relicOrichalcum != null)
					{
						player_block += relicOrichalcum.DynamicVars.Block.IntValue;
					}
				}
				var relicCloakClaps = player.Relics.FirstOrDefault(relic => relic is CloakClasp);
				if (relicCloakClaps != null)
				{
					player_block += handPile.Cards.Count;
				}
				var relicRipleBasin = player.Relics.FirstOrDefault(relic => relic is RippleBasin);
				if (relicRipleBasin != null && !CombatManager.Instance.History.CardPlaysFinished.Any((CardPlayFinishedEntry e) => e.HappenedThisTurn(combatState) && e.CardPlay.Card.Type == CardType.Attack && e.CardPlay.Card.Owner == player))
				{
					player_block += relicRipleBasin.DynamicVars.Block.IntValue;
				}

				if (num_damage_received <= player_block + player.Creature.GetPowerAmount<PlatingPower>())
				{
					//we either have no damage debuffs or we can block them so no reason to play this round further
					RunManager.Instance.ActionQueueSynchronizer.RequestEnqueue(new EndPlayerTurnAction(player, combatState.RoundNumber));
					return;
				}
			}
		}
	}

	[HarmonyPatch(typeof(NPlayerHand), nameof(NPlayerHand.SelectCards))]
	public static class Patch_SelectCards
	{
		[HarmonyPrefix]
		private static bool Prefix(NPlayerHand __instance, CardSelectorPrefs prefs, Func<CardModel, bool> filter, AbstractModel source, NPlayerHand.Mode mode, ref Task<IEnumerable<CardModel>> __result)
		{
			if (ModState.CurrentPlayer == null) return true;

			bool IsDiscardTypeOfSelect = prefs.Prompt.LocEntryKey == "TO_DISCARD";
			bool IsExhaustTypeOfSelect = prefs.Prompt.LocEntryKey == "TO_EXHAUST";

			if (IsDiscardTypeOfSelect && !ModSettings.AutomaticDiscard) return true;
			else if (IsExhaustTypeOfSelect && !ModSettings.AutomaticExhaust) return true;
			else if (!IsExhaustTypeOfSelect && !IsDiscardTypeOfSelect && !ModSettings.AutomaticSelect) return true;

			CardPile handPile = PileType.Hand.GetPile(ModState.CurrentPlayer);
			var filteredPile = handPile.Cards.Where(c => filter == null || filter(c)).ToList();

			if (filteredPile.Count == 0) return true;//if we have no cards, game already selects nothing by default, so we can leave it to original function
			else if (prefs.MaxSelect == 999999999) return true;//Gambler's Brew potion
			else if (prefs.RequireManualConfirmation || (!IsDiscardTypeOfSelect && prefs.MinSelect == 0)) return true;

			var selected = new List<CardModel> { };

			if (filteredPile.Count <= prefs.MinSelect)//if we have less cards than amount needed to select, select them automatically
			{
				for (int th = 0; th < filteredPile.Count; th++)
				{
					selected.Add(filteredPile[th]);
				}
			}
			else if (IsDiscardTypeOfSelect)//discard selection
			{
				bool has_flechettes = handPile.Cards.Any(card => card is Flechettes && card.CanPlay());
				bool has_any_exhaust_power_card = handPile.Cards.Any(card => (card is Brand || card is BurningPact || card is Scavenge || card is FlakCannon || card is SecondWind || card is Purity || card is Compact) && card.CanPlay());

				List<CardModel> cards_to_discard_optimally = [];

				for (int th = 0; th < filteredPile.Count; th++)
				{
					CardModel card = filteredPile[th];
					bool can_be_played = card.CanPlay(out UnplayableReason reason, preventer: out _);
					if (card.IsSlyThisTurn)
					{
						if (!has_flechettes || card.Type != CardType.Skill)//if Flechettes is in hand do not auto discard Sly cards unless they are not a skill
						{
							cards_to_discard_optimally.Add(card);
						}
					}
					else if (card.Type > CardType.Power)
					{
						if (!has_any_exhaust_power_card && //only consider status cards if we can't exhaust or transform them this round
							!card.Keywords.Contains(CardKeyword.Ethereal) && //if the status card is Ethereal then discarding it doesn't make a sense
							card is not FranticEscape && (card is not Slimed || !can_be_played))//exclude Frantic Escape and Slimed
						{
							cards_to_discard_optimally.Add(card);
						}
					}
					else if(card.Keywords.Contains(CardKeyword.Ethereal) && !can_be_played)//if it isn't Sly or status card and the card is ethereal and we can't play it then it should be optimal choice to discard it
					{
						cards_to_discard_optimally.Add(card);
					}
					else if(!can_be_played && ((reason & UnplayableReason.BlockedByHook) == UnplayableReason.BlockedByHook) && card.Affliction != null && card.Affliction.Id.Entry == "BOUND")//Bound cards are optimal to discard too
					{
						cards_to_discard_optimally.Add(card);
					}
				}

				if (cards_to_discard_optimally.Count == prefs.MinSelect)//if there is only one Sly or stats card it will discard it automatically - should be always the most optimal choice
				{
					for (int th = 0; th < cards_to_discard_optimally.Count; th++)
					{
						selected.Add(cards_to_discard_optimally[th]);
					}
				}
				else if (cards_to_discard_optimally.Count > prefs.MinSelect)
				{
					CardModel first = cards_to_discard_optimally[0];
					for (int th = 1; th < cards_to_discard_optimally.Count; th++)
					{
						if (!CardsEqual(first, cards_to_discard_optimally[th]))
						{
							return true;
						}
					}
					//if all optimally discardable cards are same, discard required amount automatically
					int num_to_discard = prefs.MinSelect;
					for (int th = 0; th < cards_to_discard_optimally.Count && num_to_discard > 0; th++)
					{
						selected.Add(cards_to_discard_optimally[th]);
						num_to_discard--;
					}
				}
				else
				{
					CardModel first = filteredPile[0];

					for (int th = 1; th < filteredPile.Count; th++)
					{
						if (!CardsEqual(first, filteredPile[th]))
						{
							return true;
						}
					}

					for (int th = 0; th < prefs.MinSelect; th++)
					{
						selected.Add(filteredPile[th]);
					}
				}
			}
			else if (IsExhaustTypeOfSelect)
			{
				List<CardModel> cards_to_exhaust_optimally = [];

				for (int th = 0; th < filteredPile.Count; th++)
				{
					CardModel card = filteredPile[th];
					if (!card.Keywords.Contains(CardKeyword.Ethereal) && ((card.Type > CardType.Power && card is not FranticEscape) || (card is Bombardment or HowlFromBeyond && !card.CanPlay())))
					{
						cards_to_exhaust_optimally.Add(card);
					}
				}

				if (cards_to_exhaust_optimally.Count == prefs.MinSelect)
				{
					for (int th = 0; th < cards_to_exhaust_optimally.Count; th++)
					{
						selected.Add(cards_to_exhaust_optimally[th]);
					}
				}
				else if (cards_to_exhaust_optimally.Count > prefs.MinSelect)//if all optimally exhaustable cards are same, exhaust required amount automatically
				{
					CardModel first = cards_to_exhaust_optimally[0];
					for (int th = 1; th < cards_to_exhaust_optimally.Count; th++)
					{
						if (!CardsEqual(first, cards_to_exhaust_optimally[th]))
						{
							return true;
						}
					}
					//if all optimally discardable cards are same, discard required amount automatically
					int num_to_exhaust = prefs.MinSelect;
					for (int th = 0; th < cards_to_exhaust_optimally.Count && num_to_exhaust > 0; th++)
					{
						selected.Add(cards_to_exhaust_optimally[th]);
						num_to_exhaust--;
					}
				}
				else
				{
					CardModel first = filteredPile[0];
					for (int th = 1; th < filteredPile.Count; th++)
					{
						if (!CardsEqual(first, filteredPile[th]))
						{
							return true;
						}
					}

					for (int th = 0; th < prefs.MinSelect; th++)
					{
						selected.Add(filteredPile[th]);
					}
				}
			}
			else//not discard nor exhaust selection - only select automatically when all cards in hand are identical
			{
				CardModel first = filteredPile[0];
				for (int th = 1; th < filteredPile.Count; th++)
				{
					if (!CardsEqual(first, filteredPile[th]))
					{
						return true;
					}
				}

				for (int th = 0; th < prefs.MinSelect; th++)
				{
					selected.Add(filteredPile[th]);
				}
			}

			__result = Task.FromResult<IEnumerable<CardModel>>(selected);
			return false;
		}
	}

	[HarmonyPatch(typeof(NPlayerHand), "SelectCardInSimpleMode")]
	[HarmonyPostfix]
	private static void SelectCardInSimpleMode(NPlayerHand __instance)
	{
		var prefsField = Traverse.Create(__instance).Field<CardSelectorPrefs>("_prefs");
		if (prefsField == null) return;
		var prefs = prefsField.Value;

		var selectedCards = Traverse.Create(__instance).Field<List<CardModel>>("_selectedCards").Value;
		int selectedCount = selectedCards?.Count ?? 0;

		if (prefs.MaxSelect < 1) return;
		else if (selectedCards == null || selectedCount != prefs.MaxSelect) return;

		// Press the confirm button to complete the selection
		var confirmMethod = AccessTools.Method(__instance.GetType(), "OnSelectModeConfirmButtonPressed");
		if (confirmMethod != null)
		{
			confirmMethod.Invoke(__instance, [null!]);
		}
	}

	[HarmonyPatch(typeof(CardSelectCmd), nameof(CardSelectCmd.FromHand))]
	[HarmonyPrefix]
	private static void FromHand(PlayerChoiceContext context, Player player, CardSelectorPrefs prefs, Func<CardModel, bool>? filter, AbstractModel source)
	{
		ModState.CurrentPlayer = player;
	}

	[HarmonyPatch(typeof(CardSelectCmd), nameof(CardSelectCmd.FromSimpleGrid))]
	[HarmonyPrefix]
	private static bool FromSimpleGrid(PlayerChoiceContext context, IReadOnlyList<CardModel> cardsIn, Player player, CardSelectorPrefs prefs, ref Task<IEnumerable<CardModel>> __result)
	{
		if (!ModSettings.AutomaticDiscard) return true;
		if (CombatManager.Instance.IsEnding) return true;

		List<CardModel> cards = cardsIn.ToList();
		if (!prefs.RequireManualConfirmation && cards.Count <= prefs.MinSelect)//if we have less cards than needed to select fall back to original function (it selects automatically)
		{
			return true;
		}

		CardModel first = cards[0];
		for (int th = 1; th < cards.Count; th++)
		{
			if (!CardsEqual(first, cards[th]))
			{
				return true;
			}
		}

		//if all remaining cards are identical, it will select required amount automatically
		var selected = new List<CardModel> { };
		for (int th = 0; th < prefs.MinSelect; th++)
		{
			selected.Add(cards[th]);
		}

		__result = Task.FromResult<IEnumerable<CardModel>>(selected);
		return false;
	}

	private static void AutomaticEndTurn(Player player)
	{
		if (CombatManager.Instance.IsOverOrEnding || player.Creature.CombatState == null || LocalContext.NetId != player.NetId) return;

		int damage_from_bomb = 0;

		IReadOnlyList<Creature> allies = player.Creature.CombatState.PlayerCreatures;
		for(int th = 0; th < allies.Count; th++)
		{
			Creature ally = allies[th];
			var bombPower = ally.GetPower<TheBombPower>();
			if (bombPower != null && bombPower.Amount == 1)
			{
				damage_from_bomb+= bombPower.DynamicVars.Damage.IntValue;
			}
		}

		int num_enemies_survive_this_turn = 0, num_enemies_alive = 0, num_minions_survive_this_turn = 0, num_enemies_intends_attack = 0, num_weak_enemies = 0, num_damage_received = 0;
		List<(Creature creature, int value)> remaining_enemies_alive = [];
		bool doom_potion_useful = false;
		bool no_draw = player.Creature.HasPower<NoDrawPower>();

		IReadOnlyList<Creature> enemies = player.Creature.CombatState.Enemies;
		for (int th = 0; th < enemies.Count; th++)
		{
			Creature enemy = enemies[th];

			if (enemy.IsAlive || enemy.Monster is TestSubject) num_enemies_alive++;
			else continue;

			int damage_from_poison = (enemy.GetPower<PoisonPower>()?.CalculateTotalDamageNextTurn() ?? 0);

			if (enemy.Monster is Doormaker || enemy.GetPowerAmount<StockPower>() > 0 || enemy.GetPowerAmount<SurprisePower>() > 0 || enemy.GetPowerAmount<InfestedPower>() > 0 || enemy.GetPowerAmount<SteamEruptionPower>() > 0 || enemy.GetPowerAmount<AdaptablePower>() > 0 || damage_from_poison + damage_from_bomb < enemy.CurrentHp)
			{
				num_enemies_survive_this_turn++;
				int num_enemy_damage = 0;

				if (enemy.HasPower<MinionPower>())
				{
					num_minions_survive_this_turn++;
				}
				if (enemy.HasPower<ScrutinyPower>())
				{
					no_draw = true;
				}
				if (enemy.GetPowerAmount<DoomPower>() < enemy.CurrentHp)
				{
					doom_potion_useful = true;
				}

				if (enemy.Monster?.IntendsToAttack == true)
				{
					num_enemies_intends_attack++;
					if (enemy.GetPowerAmount<WeakPower>() > 0)
					{
						num_weak_enemies++;
					}
					foreach (var intent in enemy.Monster.NextMove.Intents)
					{
						if (intent is AttackIntent attackIntent)
						{
							num_enemy_damage += attackIntent.GetTotalDamage(allies, owner: enemy);
						}
					}
				}
				int hp_after_poison = enemy.CurrentHp - damage_from_poison - damage_from_bomb - enemy.GetPowerAmount<PlowPower>() - enemy.GetPowerAmount<ShriekPower>() + enemy.Block;
				if (hp_after_poison > 0)
				{
					remaining_enemies_alive.Add((enemy, hp_after_poison));
					num_damage_received += num_enemy_damage;
				}
			}
		}

		CardPile handPile = PileType.Hand.GetPile(player);
		CardPile drawPile = PileType.Draw.GetPile(player);
		CardPile discardPile = PileType.Discard.GetPile(player);
		var all_reachable_cards = handPile.Cards.Concat(drawPile.Cards).Concat(discardPile.Cards);

		for (int th = 0; th < handPile.Cards.Count; th++)
		{
			CardModel card = handPile.Cards[th];
			if (card.Type > CardType.Power)
			{
				if (card.DynamicVars.ContainsKey("Damage"))
				{
					num_damage_received += card.DynamicVars.Damage.IntValue;
				}
				else if (card.DynamicVars.ContainsKey("HpLoss"))
				{
					num_damage_received += card.DynamicVars.HpLoss.IntValue;
				}
			}
		}

		num_damage_received += player.Creature.GetPowerAmount<DisintegrationPower>() + player.Creature.GetPowerAmount<ConstrictPower>();

		int player_block = player.Creature.Block;
		if (player_block == 0)
		{
			var relicOrichalcum = player.Relics.FirstOrDefault(relic => relic is Orichalcum);
			if (relicOrichalcum != null)
			{
				player_block += relicOrichalcum.DynamicVars.Block.IntValue;
			}
			relicOrichalcum = player.Relics.FirstOrDefault(relic => relic is FakeOrichalcum);
			if (relicOrichalcum != null)
			{
				player_block += relicOrichalcum.DynamicVars.Block.IntValue;
			}
		}
		var relicCloakClaps = player.Relics.FirstOrDefault(relic => relic is CloakClasp);
		if (relicCloakClaps != null)
		{
			player_block += handPile.Cards.Count;
		}
		var relicRipleBasin = player.Relics.FirstOrDefault(relic => relic is RippleBasin);
		if (relicRipleBasin != null && !CombatManager.Instance.History.CardPlaysFinished.Any((CardPlayFinishedEntry e) => e.HappenedThisTurn(player.Creature.CombatState) && e.CardPlay.Card.Type == CardType.Attack && e.CardPlay.Card.Owner == player))
		{
			player_block += relicRipleBasin.DynamicVars.Block.IntValue;
		}

		num_damage_received -= player_block + player.Creature.GetPowerAmount<PlatingPower>();

		if (num_enemies_survive_this_turn == 0 || num_enemies_survive_this_turn == num_minions_survive_this_turn)//no enemies will survive after this card was played
		{
			bool has_any_card_counting_relic = player.Relics.Any(relic => relic is PenNib or Nunchaku or TuningFork or IronClub or GalacticDust);
			bool has_fatal_or_alchemize_card = all_reachable_cards.Any(card => card is Feed or TheHunt or HandOfGreed or Alchemize or NotYet && player.Creature.CurrentHp < player.Creature.MaxHp);

			if (!has_fatal_or_alchemize_card && !has_any_card_counting_relic && num_damage_received <= 0)
			{
				//we either have no damage debuffs or we can block them so no reason to play this round further
				RunManager.Instance.ActionQueueSynchronizer.RequestEnqueue(new EndPlayerTurnAction(player, player.Creature.CombatState.RoundNumber));
				return;
			}
		}

		int num_playable_cards = 0, num_upgradable_cards = 0, num_ethereal_cards = 0, num_cards_using_energy = 0, num_cards_using_stars = 0, minimum_energy_needed_to_play_card = 99, minimum_stars_needed_to_play_card = 99;

		for (int th = 0; th < handPile.Cards.Count; th++)
		{
			CardModel card = handPile.Cards[th];
			int card_star_cost = card.GetStarCostWithModifiers();
			int card_energy_cost = card.EnergyCost.GetWithModifiers(CostModifiers.All);
			//Log.Info(th + ". card: " + card.Title + " card_type: " + card.Type + " card_star_cost: " + card_star_cost + ", card_energy_cost: " + card_energy_cost);

			if (card.CanPlay(out UnplayableReason reason, preventer: out _) && (num_enemies_alive > 0 || (card.TargetType != TargetType.AnyEnemy && card.TargetType != TargetType.RandomEnemy && card.TargetType != TargetType.AllEnemies)))
			{
				return;
			}
			else if ((reason & (UnplayableReason.HasUnplayableKeyword | UnplayableReason.BlockedByHook | UnplayableReason.BlockedByCardLogic)) == 0)
			{
				num_playable_cards++;
			}
			if (card.IsUpgradable)
			{
				num_upgradable_cards++;
			}
			if(card.Keywords.Contains(CardKeyword.Ethereal))
			{
				num_ethereal_cards++;
			}
			if (card_energy_cost > 0 && reason == UnplayableReason.EnergyCostTooHigh)
			{
				num_cards_using_energy++;
				if (card_energy_cost < minimum_energy_needed_to_play_card)
				{
					minimum_energy_needed_to_play_card = card_energy_cost;
				}
			}
			if (card_star_cost > 0 && reason == UnplayableReason.StarCostTooHigh)
			{
				num_cards_using_stars++;
				if (card_star_cost < minimum_stars_needed_to_play_card)
				{
					minimum_stars_needed_to_play_card = card_star_cost;
				}
			}
		}

		bool any_playable_card_in_draw_pile = drawPile.Cards.Any(card => card.Keywords.Contains(CardKeyword.Unplayable) == false);
		bool any_playable_card_in_discard_pile = discardPile.Cards.Any(card => card.Keywords.Contains(CardKeyword.Unplayable) == false);
		int total_damage_from_potions = 0;
		int num_cards_played_this_turn = CombatManager.Instance.History.CardPlaysStarted.Count(e =>	e.HappenedThisTurn(player.Creature.CombatState) &&e.CardPlay.Card.Owner.Creature == player.Creature);
		var sloth = player.Creature.GetPower<SlothPower>();
		bool no_play = (player.Creature.HasPower<RingingPower>() && num_cards_played_this_turn > 0) || (sloth != null && num_cards_played_this_turn >= sloth.Amount);

		//if we got here, we have no cards to play or no energy to play them
		foreach (PotionModel pot in player.Potions)
		{
			if (pot.Usage == PotionUsage.Automatic)//automatically used potions can be safely ignored
			{
				//ignore
			}
			else if (pot is GigantificationPotion or SoldiersStew or Duplicator)//if we have no playable attack cards in hand, then potions that improve attack cards are useless
			{
				//ignore
			}
			else if (no_play && pot is SneckoOil or EnergyPotion or StarPotion or RadiantTincture or PotOfGhouls)//if we can't play any more cards this round then potions that allows to play cards in hand are useless
			{
				//ignore
			}
			else if ((no_draw || no_play || handPile.Cards.Count >= 10) && (pot is AttackPotion or ColorlessPotion or PowerPotion or SkillPotion or SwiftPotion or Clarity or CunningPotion or KingsCourage or DropletOfPrecognition or LiquidMemories or OrobicAcid or CosmicConcoction))//if we can't draw additional cards, then potions that adds cards are useless
			{
				//ignore
			}
			else if (((no_draw || no_play) && handPile.Cards.Count == num_ethereal_cards) && pot is GlowwaterPotion)//if there isn't anything to exhaust and we can't draw additional cards, then Glowwater Potion is useless
			{
				//ignore
			}
			else if (pot.TargetType == TargetType.AnyPlayer && (pot.DynamicVars.ContainsKey("StrengthPower") || pot.DynamicVars.ContainsKey("DexterityPower")))//if we can't play any card, then potions that adds Strength or Dexterity are useless
			{
				//ignore
			}
			else if (pot.DynamicVars.ContainsKey("Forge"))//if we can't play any card, then potions that Forges are useless
			{
				//ignore
			}
			else if ((player.Creature.Block <= 0 || num_damage_received <= 0 || num_enemies_intends_attack == 0) && pot is Fortifier)//if we have no block, or we won't receive any damage then potions that multiply block are useless
			{
				//ignore
			}
			else if ((num_damage_received <= 0 || num_enemies_intends_attack == 0) && (pot.DynamicVars.ContainsKey("Block") || pot.DynamicVars.ContainsKey("PlatingPower") || pot.DynamicVars.ContainsKey("BufferPower") || pot.DynamicVars.ContainsKey("IntangiblePower")))//if no enemy intends to attack, then potions that reduces damage taken are useless
			{
				//ignore
			}
			else if ((num_enemies_intends_attack == 0 || num_damage_received <= 0 || num_weak_enemies == num_enemies_intends_attack) && pot.DynamicVars.ContainsKey("WeakPower"))//if no enemy intends to attack, then potions that weakens enemy are useless
			{
				//ignore
			}
			else if ((num_enemies_intends_attack == 0 || num_damage_received <= 0) && pot.DynamicVars.ContainsKey("DamageDecrease"))//if no enemy intends to attack, then potions that weakens enemy are useless
			{
				//ignore
			}
			else if (pot.DynamicVars.ContainsKey("VulnerablePower") && !pot.DynamicVars.ContainsKey("WeakPower"))//if we can't play any card, then potions that adds Vulnerability are useless
			{
				//ignore
			}
			else if ((num_enemies_intends_attack == 0 || num_damage_received <= 0) && (pot.TargetType == TargetType.AllEnemies || pot.TargetType == TargetType.AnyEnemy || pot.TargetType == TargetType.RandomEnemy) && pot.DynamicVars.ContainsKey("StrengthPower"))//if no enemy intends to attack, then potions that reduces enemy Strength are useless
			{
				//ignore
			}
			else if (player.Creature.CurrentHp >= player.Creature.MaxHp && (pot.DynamicVars.ContainsKey("MaxHp") || pot.DynamicVars.ContainsKey("HealPercent") || pot.DynamicVars.ContainsKey("RegenPower")))//if we have maximum HP, then potions that modify HPs are useless
			{
				//ignore
			}
			else if (pot.DynamicVars.ContainsKey("Energy") && !pot.DynamicVars.ContainsKey("Cards") && minimum_energy_needed_to_play_card > pot.DynamicVars.Energy.IntValue)//if we have no cards in hand that uses energy or only cards with higher energy cost than we can get, then potions that gives us energy are useless
			{
				//ignore
			}
			else if (pot.DynamicVars.ContainsKey("Energy") && pot.DynamicVars.ContainsKey("Cards") && (no_play || (no_draw && minimum_energy_needed_to_play_card > pot.DynamicVars.Energy.IntValue)))//Cure All conditions are bit different
			{
				//ignore
			}
			else if (pot.DynamicVars.ContainsKey("Stars") && minimum_stars_needed_to_play_card > pot.DynamicVars.Stars.IntValue)//if we have no cards in hand that uses stars or only cards with higher stars cost than we can get, then potions that gives us stars are useless
			{
				//ignore
			}
			else if ((handPile.Cards.Count == 0 || (handPile.Cards.Count == num_ethereal_cards && (no_draw || no_play))) && pot is GamblersBrew)//if there are only ethereal cards in hand, and we can't draw any more cards then Gambler's Brew is useless
			{
				//ignore
			}
			else if (handPile.Cards.Count == 0 && (pot is Ashwater or BottledPotential))//if we have no cards in hand, then potions that does something with cards in hand are useless
			{
				//ignore
			}
			else if ((drawPile.Cards.Count == 0 || !any_playable_card_in_draw_pile) && (pot is DistilledChaos or DropletOfPrecognition))//if we have no cards in draw pile, then potions that plays cards from draw pile are useless
			{
				//ignore
			}
			else if ((discardPile.Cards.Count == 0 || !any_playable_card_in_discard_pile) && pot is LiquidMemories)//if we have no cards in discard pile, then potions that plays cards from discard pile are useless
			{
				//ignore
			}
			else if (handPile.Cards.Count == num_ethereal_cards && (pot is StableSerum or Ashwater))//if there are only ethereal cards in hand, then potions that retain or exhaust are useless
			{
				//ignore
			}
			else if (num_playable_cards == 0 && (pot is BlessingOfTheForge or TouchOfInsanity))//if we have no playable cards in hand, then potions that retains or improve cards in hand are useless
			{
				//ignore
			}
			else if (num_upgradable_cards == 0 && pot is BlessingOfTheForge)//if we have no upgradable cards in hand, then potions that upgrade cards are useless
			{
				//ignore
			}
			else if (!doom_potion_useful && pot is PotionOfDoom)//if all enemies have more doom then their HP already, then doom potion is useless
			{
				//potion
			}
			else if (pot.DynamicVars.ContainsKey("Damage"))//note: damage potions ignore vulnerable and plating
			{
				total_damage_from_potions += pot.DynamicVars.Damage.IntValue;
			}
			else
			{
				//NRun.Instance?.GlobalUi.TopBar.PotionContainer.AnimatePotion(another_potion);
				return;//if we get here we have some potion that can still benefit us this turn
			}
		}

		if (total_damage_from_potions > 0)//if we can't kill any enemy with our potions, then potions that deals damage are useless
		{
			for (int th = 0; th < remaining_enemies_alive.Count; th++)
			{
				int damage_from_potions_to_this_enemy = total_damage_from_potions;
				var (enemy, remaining_hp) = remaining_enemies_alive[0];
				var hardenedShell = enemy.GetPower<HardenedShellPower>();
				if (hardenedShell != null)
				{
					if (hardenedShell.DisplayAmount > 0) return;//if Hardened Shell blocked all damage this round then end turn automatically
					break;
				}
				if (enemy.IsAlive && remaining_hp <= total_damage_from_potions && hardenedShell == null)
				{
					return;
				}
			}
		}

		//if it falls here, we have no cards to play at all and no potions which would have sense to use, then end turn automatically
		RunManager.Instance.ActionQueueSynchronizer.RequestEnqueue(new EndPlayerTurnAction(player, player.Creature.CombatState.RoundNumber));			
	}

	public static bool IsAutoPlayable(CardModel? card)
	{
		if (card?.CombatState == null) return false;

		return card.TargetType switch
		{
			TargetType.None or TargetType.Self or TargetType.AllEnemies or TargetType.RandomEnemy => true,
			TargetType.AnyEnemy => card.CombatState.HittableEnemies.Count == 1 || (ModSettings.HardSelect && ModState.TargettedEnemy != null && !ModState.TargettedEnemy.Entity.IsDead),
			_ => false
		};
	}

	public static bool IsAutoPlayable(PotionModel? potion)
	{
		if (potion?.Owner.Creature.CombatState == null) return false;

		return potion.TargetType switch
		{
			TargetType.None or TargetType.Self or TargetType.AllEnemies or TargetType.RandomEnemy => true,
			TargetType.AnyEnemy => potion.Owner.Creature.CombatState.HittableEnemies.Count == 1 || (ModSettings.HardSelect && ModState.TargettedEnemy != null && !ModState.TargettedEnemy.Entity.IsDead),
			_ => false
		};
	}

	public static bool CardsEqual(CardModel? cardA, CardModel? cardB)
	{
		if (cardA == null || cardB == null) return false;
		if (cardA.Type != cardB.Type) return false;
		else if (cardA.Type != cardB.Type) return false;
		else if (cardA.Rarity != cardB.Rarity) return false;
		else if (cardA.Id.Entry != cardB.Id.Entry) return false;
		else if (cardA.CurrentUpgradeLevel != cardB.CurrentUpgradeLevel) return false;
		if (cardA.Enchantment == null && cardB.Enchantment != null) return false;
		else if (cardA.Enchantment != null && cardB.Enchantment != null)
		{
			if (cardA.Enchantment.Id.Entry != cardB.Enchantment.Id.Entry)
			{
				return false;
			}
		}
		if (cardA.Affliction == null && cardB.Affliction != null) return false;
		else if (cardA.Affliction != null && cardB.Affliction != null)
		{
			if (cardA.Affliction.Id.Entry != cardB.Affliction.Id.Entry)
			{
				return false;
			}
		}
		return true;
	}

	public static class ModState
	{
		public static Player? CurrentPlayer;
		public static NCreature? TargettedEnemy;
		public static bool DoNotHideReticle;
		public static ulong IgnoreEnemyClickUntilMs;
		public static bool IgnoreCardPlay;
	}
}