using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using Microsoft.CodeAnalysis;
using Ror2Meeeee.Core.Eligibility;
using Ror2Meeeee.Core.Pipeline;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Ror2Meeeee.Core")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+47d3711113ead05e4a0dd86c182991233f903141")]
[assembly: AssemblyProduct("Ror2Meeeee.Core")]
[assembly: AssemblyTitle("Ror2Meeeee.Core")]
[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.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Ror2Meeeee
{
	public static class ModInfo
	{
		public const string Guid = "com.sawcunha.ror2meeeee";

		public const string Name = "Ror2Meeeee";

		public const string Version = "0.10.4";

		public const string ExpectedGameVersion = "1.5.0#1224";
	}
}
namespace Ror2Meeeee.Core.Tax
{
	public static class TaxRelief
	{
		public const int WhitePercent = 20;

		public const int GreenPercent = 30;

		public const int RedPercent = 50;

		public const int WhiteGoldPercent = 10;

		public const int GreenGoldPercent = 20;

		public const int RedGoldPercent = 30;

		public static float Multiplier(bool white, bool green, bool red)
		{
			int num = (white ? 20 : 0) + (green ? 30 : 0) + (red ? 50 : 0);
			return (float)(100 - num) / 100f;
		}

		public static uint Gold(uint amount, bool white, bool green, bool red)
		{
			int num = (white ? 10 : 0) + (green ? 20 : 0) + (red ? 30 : 0);
			if (num == 0 || amount == 0)
			{
				return amount;
			}
			ulong num2 = (ulong)(amount * (100 + num) + 50) / 100uL;
			if (num2 <= uint.MaxValue)
			{
				return (uint)num2;
			}
			return uint.MaxValue;
		}
	}
}
namespace Ror2Meeeee.Core.Stats
{
	public static class Bastion
	{
		public const float ShieldPerStack = 0.4f;

		public const float RegenDelaySeconds = 2f;

		public static float ExtraShield(float maxHealth, int stacks)
		{
			if (stacks > 0 && !(maxHealth <= 0f))
			{
				return maxHealth * 0.4f * (float)stacks;
			}
			return 0f;
		}

		public static bool ShouldForceRegen(float timeSinceLastHit, float shield, float maxShield)
		{
			if (maxShield > 0f && shield < maxShield)
			{
				return timeSinceLastHit >= 2f;
			}
			return false;
		}
	}
	public static class HeavyHeart
	{
		public const float HealthPerStack = 0.5f;

		public const float DamageTakenPerStack = 0.3f;

		public const double MaxMultiplier = 1E+30;

		public static float HealthMultiplier(int stacks)
		{
			return Compound(1.5, stacks);
		}

		public static float DamageTakenMultiplier(int stacks)
		{
			return Compound(1.300000011920929, stacks);
		}

		private static float Compound(double factor, int stacks)
		{
			if (stacks <= 0)
			{
				return 1f;
			}
			double num = Math.Pow(factor, stacks);
			return (float)((num < 1E+30) ? num : 1E+30);
		}
	}
	public static class MultiShot
	{
		public static int ExtraShots(int stacks, int maxExtra)
		{
			if (stacks <= 0 || maxExtra <= 0)
			{
				return 0;
			}
			if (stacks >= maxExtra)
			{
				return maxExtra;
			}
			return stacks;
		}

		public static float FanAngle(int index, float step)
		{
			if (index < 0)
			{
				return 0f;
			}
			int num = index / 2 + 1;
			return ((index % 2 == 0) ? 1f : (-1f)) * (float)num * step;
		}

		public static int Budget(int wanted, int usedThisFrame, int maxPerFrame)
		{
			int num = maxPerFrame - usedThisFrame;
			if (wanted <= 0 || num <= 0)
			{
				return 0;
			}
			if (wanted >= num)
			{
				return num;
			}
			return wanted;
		}
	}
	public static class PortalBattery
	{
		public const float ChargePerStack = 0.1f;

		public static float ChargeRateMultiplier(int teamStacks)
		{
			if (teamStacks > 0)
			{
				return 1f + 0.1f * (float)teamStacks;
			}
			return 1f;
		}
	}
	public static class SelfHeal
	{
		public const float SelfishFlat = 5f;

		public const float SelfishPerStack = 0.0001f;

		public const float VoidFlat = 15f;

		public const float VoidPerStack = 0.005f;

		public const float LevelScaling = 0.2f;

		public static float PerSecond(int stacks, float flat, float perExtraStack, float fullHealth, float level)
		{
			if (stacks <= 0)
			{
				return 0f;
			}
			float num = ((level < 1f) ? 1f : level);
			return flat * (1f + 0.2f * (num - 1f)) + perExtraStack * (float)(stacks - 1) * fullHealth;
		}

		public static float AmountPerTick(int selfish, int voidStacks, float fullHealth, float level, float interval)
		{
			if (interval <= 0f)
			{
				return 0f;
			}
			return (PerSecond(selfish, 5f, 0.0001f, fullHealth, level) + PerSecond(voidStacks, 15f, 0.005f, fullHealth, level)) * interval;
		}
	}
	public static class ShortNumber
	{
		private static readonly CultureInfo Pt = CultureInfo.GetCultureInfo("pt-BR");

		private static readonly (double Div, string Suffix)[] Steps = new(double, string)[4]
		{
			(1000000000000.0, " tri"),
			(1000000000.0, " bi"),
			(1000000.0, " mi"),
			(1000.0, " mil")
		};

		public static string Format(double value)
		{
			double num = ((value < 0.0) ? (0.0 - value) : value);
			(double, string)[] steps = Steps;
			for (int i = 0; i < steps.Length; i++)
			{
				var (num2, text) = steps[i];
				if (num >= num2)
				{
					return (value / num2).ToString("0.#", Pt) + text;
				}
			}
			return value.ToString("0", Pt);
		}
	}
	public static class SpeedToDamage
	{
		public const float FirstStackRatio = 1f;

		public const float ExtraStackRatio = 0.5f;

		public static float Ratio(int stacks)
		{
			if (stacks > 0)
			{
				return 1f + 0.5f * (float)(stacks - 1);
			}
			return 0f;
		}

		public static bool Convert(float moveSpeed, float neutralSpeed, float damage, int stacks, out float newSpeed, out float newDamage)
		{
			newSpeed = moveSpeed;
			newDamage = damage;
			if (stacks <= 0 || !(neutralSpeed > 0f) || !(moveSpeed > neutralSpeed) || float.IsInfinity(moveSpeed) || float.IsNaN(damage))
			{
				return false;
			}
			float num = moveSpeed / neutralSpeed - 1f;
			newSpeed = neutralSpeed;
			newDamage = damage * (1f + num * Ratio(stacks));
			return true;
		}
	}
	public static class StatPool
	{
		public const float MaxCombined = 1E+09f;

		public static float ClampScale(float maxHealth, float maxShield)
		{
			float num = maxHealth + maxShield;
			if (!(num > 1E+09f) || !(num > 0f))
			{
				return 1f;
			}
			return 1E+09f / num;
		}

		public static float Adjust(float current, float previousMax, float newMax)
		{
			float num = newMax - previousMax;
			float num2 = ((num > 0f) ? (current + num) : current);
			if (!(num2 < newMax))
			{
				return newMax;
			}
			return num2;
		}
	}
}
namespace Ror2Meeeee.Core.Spend
{
	public readonly struct SpendRow
	{
		public int Id { get; }

		public string Name { get; }

		public int Purchases { get; }

		public long Gold { get; }

		public SpendRow(int id, string name, int purchases, long gold)
		{
			Id = id;
			Name = name;
			Purchases = purchases;
			Gold = gold;
		}
	}
	public sealed class SpendLedger
	{
		private sealed class Entry
		{
			public string Name;

			public int Purchases;

			public long Gold;
		}

		private readonly Dictionary<int, Entry> _byId = new Dictionary<int, Entry>();

		public int Players => _byId.Count;

		public bool Knows(int id)
		{
			return _byId.ContainsKey(id);
		}

		public void Add(int id, Func<string> name, long gold)
		{
			if (!_byId.TryGetValue(id, out var value))
			{
				value = new Entry
				{
					Name = (name() ?? ("#" + id.ToString(CultureInfo.InvariantCulture)))
				};
				_byId[id] = value;
			}
			value.Purchases++;
			if (gold > 0)
			{
				value.Gold = ((long.MaxValue - value.Gold < gold) ? long.MaxValue : (value.Gold + gold));
			}
		}

		public void Clear()
		{
			_byId.Clear();
		}

		public SpendRow[] Snapshot()
		{
			SpendRow[] array = new SpendRow[_byId.Count];
			int num = 0;
			foreach (KeyValuePair<int, Entry> item in _byId)
			{
				array[num++] = new SpendRow(item.Key, item.Value.Name, item.Value.Purchases, item.Value.Gold);
			}
			Array.Sort(array, (SpendRow a, SpendRow b) => b.Gold.CompareTo(a.Gold));
			return array;
		}

		public static string Format(SpendRow[] rows)
		{
			if (rows.Length == 0)
			{
				return "Nenhuma compra registrada nesta run.";
			}
			StringBuilder stringBuilder = new StringBuilder("Jogador | Compras | Ouro gasto");
			long num = 0L;
			for (int i = 0; i < rows.Length; i++)
			{
				SpendRow spendRow = rows[i];
				stringBuilder.Append('\n').Append(spendRow.Name).Append(" | ")
					.Append(spendRow.Purchases)
					.Append(" | ")
					.Append(spendRow.Gold);
				num += spendRow.Gold;
			}
			stringBuilder.Append("\nTotal | | ").Append(num);
			return stringBuilder.ToString();
		}
	}
}
namespace Ror2Meeeee.Core.RustyNail
{
	public static class RustyNailRules
	{
		public const float ChanceBase = 2f;

		public const float ChancePerStack = 0.1f;

		public const float VoidChancePerStack = 0.5f;

		public const float NailBase = 0.1f;

		public const float NailPerStack = 0.001f;

		public const float VoidNailPerStack = 0.005f;

		public const float BleedDuration = 3f;

		public const float MarkDuration = 3f;

		public const float DetonationCoefficient = 2.5f;

		public const float BurstBase = 1.5f;

		public const float BurstPerStack = 0.5f;

		public const float BurstRadius = 12f;

		public const int MaxActiveMarks = 200;

		public static float ChancePercent(int stacks, float perStack)
		{
			if (stacks <= 0)
			{
				return 0f;
			}
			float num = 2f + perStack * (float)(stacks - 1);
			if (!(num < 100f))
			{
				return 100f;
			}
			return num;
		}

		public static float NailCoefficient(int stacks, float perStack)
		{
			if (stacks > 0)
			{
				return 0.1f + perStack * (float)(stacks - 1);
			}
			return 0f;
		}

		public static float BurstCoefficient(int stacks)
		{
			if (stacks > 0)
			{
				return 1.5f + 0.5f * (float)(stacks - 1);
			}
			return 0f;
		}

		public static bool CanSpread(int generation, int maxChain)
		{
			return generation < maxChain;
		}
	}
}
namespace Ror2Meeeee.Core.Progression
{
	public readonly struct LadderRules
	{
		public float RaiseAt { get; }

		public float Step { get; }

		public float MaxMultiplier { get; }

		public LadderRules(float raiseAt, float step, float maxMultiplier)
		{
			RaiseAt = raiseAt;
			Step = step;
			MaxMultiplier = maxMultiplier;
		}
	}
	public static class ProgressionLadder
	{
		public static int Next(int level, float score, bool won, LadderRules r)
		{
			level = Math.Max(0, level);
			int val = ((!won) ? (level - 1) : ((!float.IsNaN(score) && score >= r.RaiseAt) ? (level + 1) : level));
			return Math.Max(0, Math.Min(val, MaxLevel(r)));
		}

		public static int MaxLevel(LadderRules r)
		{
			if (!ValidStep(r.Step) || !(r.MaxMultiplier > 1f) || float.IsInfinity(r.MaxMultiplier))
			{
				return 0;
			}
			return (int)Math.Min(10000.0, Math.Ceiling(((double)r.MaxMultiplier - 1.0) / (double)r.Step - 1E-06));
		}

		public static float Multiplier(int level, LadderRules r)
		{
			if (level <= 0 || !ValidStep(r.Step) || !(r.MaxMultiplier > 1f))
			{
				return 1f;
			}
			return (float)Math.Min(r.MaxMultiplier, 1.0 + (double)level * (double)r.Step);
		}

		private static bool ValidStep(float step)
		{
			if (!float.IsNaN(step) && !float.IsInfinity(step))
			{
				return step > 0f;
			}
			return false;
		}

		public static string Serialize(int level, int runs)
		{
			return "level=" + Math.Max(0, level).ToString(CultureInfo.InvariantCulture) + "\nruns=" + Math.Max(0, runs).ToString(CultureInfo.InvariantCulture) + "\n";
		}

		public static void Parse(string text, out int level, out int runs)
		{
			level = 0;
			runs = 0;
			if (string.IsNullOrEmpty(text))
			{
				return;
			}
			string[] array = text.Split('\n');
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].Trim();
				int num = text2.IndexOf('=');
				if (num <= 0 || !int.TryParse(text2.Substring(num + 1).Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) || result < 0)
				{
					continue;
				}
				string text3 = text2.Substring(0, num).Trim();
				if (!(text3 == "level"))
				{
					if (text3 == "runs")
					{
						runs = result;
					}
				}
				else
				{
					level = result;
				}
			}
		}

		public static string Summary(RunStats s, RunScoreResult score, int oldLevel, int newLevel, float newMultiplier)
		{
			CultureInfo invariantCulture = CultureInfo.InvariantCulture;
			double num = s.Seconds / 60.0;
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("<color=#e5c07b>Ror2Meeeee</color> ").Append(s.Won ? "vitória" : "derrota").Append(" em ")
				.Append(num.ToString("F1", invariantCulture))
				.Append(" min | nota ")
				.Append((score.Total * 100f).ToString("F0", invariantCulture))
				.Append("/100\n");
			stringBuilder.Append("velocidade ").Append(Pct(score.Speed)).Append(" · sobrevivência ")
				.Append(Pct(score.Survival))
				.Append(" · dano sofrido ")
				.Append(Pct(score.Damage))
				.Append(" · abates ")
				.Append(Pct(score.Kills))
				.Append('\n');
			stringBuilder.Append(s.Kills).Append(" abates, ").Append(s.Deaths)
				.Append(" mortes, ")
				.Append(s.HealthBarsLost.ToString("F1", invariantCulture))
				.Append(" vidas de dano sofrido\n");
			string value = ((newLevel > oldLevel) ? "sobe" : ((newLevel < oldLevel) ? "desce" : "mantém"));
			stringBuilder.Append("Diretor ").Append(value).Append(": nível ")
				.Append(oldLevel)
				.Append(" -> ")
				.Append(newLevel)
				.Append(" (orçamento de spawn x")
				.Append(newMultiplier.ToString("F2", invariantCulture))
				.Append(" na próxima run)");
			return stringBuilder.ToString();
		}

		private static string Pct(float v)
		{
			return (v * 100f).ToString("F0", CultureInfo.InvariantCulture);
		}
	}
	public readonly struct ScorePars
	{
		public float ChargeSeconds { get; }

		public float DeathsPerPlayer { get; }

		public float HealthBarsPerPlayerMinute { get; }

		public float KillsPerMinute { get; }

		public ScorePars(float chargeSeconds, float deathsPerPlayer, float healthBarsPerPlayerMinute, float killsPerMinute)
		{
			ChargeSeconds = chargeSeconds;
			DeathsPerPlayer = deathsPerPlayer;
			HealthBarsPerPlayerMinute = healthBarsPerPlayerMinute;
			KillsPerMinute = killsPerMinute;
		}
	}
	public readonly struct RunScoreResult
	{
		public float Speed { get; }

		public float Survival { get; }

		public float Damage { get; }

		public float Kills { get; }

		public float Total { get; }

		public RunScoreResult(float speed, float survival, float damage, float kills)
		{
			Speed = speed;
			Survival = survival;
			Damage = damage;
			Kills = kills;
			Total = (speed + survival + damage + kills) / 4f;
		}
	}
	public static class RunScore
	{
		public const float Neutral = 0.5f;

		public static RunScoreResult Compute(RunStats s, ScorePars p)
		{
			int num = Math.Max(1, s.Players);
			double num2 = s.Seconds / 60.0;
			float speed = ((s.ChargedStages > 0) ? Lower(s.ChargeSeconds / (double)s.ChargedStages, p.ChargeSeconds) : 0.5f);
			float survival = Lower((double)s.Deaths / (double)num, p.DeathsPerPlayer);
			float damage = ((num2 > 0.0) ? Lower(s.HealthBarsLost / (double)num / num2, p.HealthBarsPerPlayerMinute) : 0.5f);
			float kills = ((num2 > 0.0) ? Higher((double)s.Kills / num2, p.KillsPerMinute) : 0.5f);
			return new RunScoreResult(speed, survival, damage, kills);
		}

		internal static float Lower(double value, float par)
		{
			if (!Valid(par) || double.IsNaN(value))
			{
				return 0.5f;
			}
			return (float)((double)par / ((double)par + Math.Max(0.0, value)));
		}

		internal static float Higher(double value, float par)
		{
			if (!Valid(par) || double.IsNaN(value))
			{
				return 0.5f;
			}
			double num = Math.Max(0.0, value);
			return (float)(num / (num + (double)par));
		}

		private static bool Valid(float par)
		{
			if (!float.IsNaN(par) && !float.IsInfinity(par))
			{
				return par > 0f;
			}
			return false;
		}
	}
	public readonly struct RunStats
	{
		public int Players { get; }

		public double Seconds { get; }

		public int ChargedStages { get; }

		public double ChargeSeconds { get; }

		public int Deaths { get; }

		public int Kills { get; }

		public double HealthBarsLost { get; }

		public bool Won { get; }

		public RunStats(int players, double seconds, int chargedStages, double chargeSeconds, int deaths, int kills, double healthBarsLost, bool won)
		{
			Players = players;
			Seconds = seconds;
			ChargedStages = chargedStages;
			ChargeSeconds = chargeSeconds;
			Deaths = deaths;
			Kills = kills;
			HealthBarsLost = healthBarsLost;
			Won = won;
		}
	}
}
namespace Ror2Meeeee.Core.Pipeline
{
	public readonly struct PickupContext
	{
		public ItemKind Kind { get; }

		public int Count { get; }

		public int CurrentStack { get; }

		public bool PlayerAlive { get; }

		public bool PlayerConnected { get; }

		public bool CapExempt { get; }

		public PickupContext(ItemKind kind, int count, int currentStack, bool playerAlive, bool playerConnected, bool capExempt)
		{
			Kind = kind;
			Count = count;
			CurrentStack = currentStack;
			PlayerAlive = playerAlive;
			PlayerConnected = playerConnected;
			CapExempt = capExempt;
		}
	}
	public readonly struct MultiplierRules
	{
		public const int DefaultMultiplier = 10;

		public int Multiplier { get; }

		public bool IncludeLunar { get; }

		public bool IncludeVoid { get; }

		public int StackCap { get; }

		public MultiplierRules(int multiplier, bool includeLunar, bool includeVoid, int stackCap)
		{
			Multiplier = ((multiplier <= 0) ? 10 : multiplier);
			IncludeLunar = includeLunar;
			IncludeVoid = includeVoid;
			StackCap = ((stackCap >= 0) ? stackCap : 0);
		}
	}
	public static class MultiplierPipeline
	{
		public static bool AtHardCap(int currentStack, MultiplierRules rules)
		{
			if (rules.StackCap > 0)
			{
				return currentStack >= rules.StackCap;
			}
			return false;
		}

		public static int Resolve(PickupContext ctx, MultiplierRules rules)
		{
			if (!ctx.PlayerAlive || !ctx.PlayerConnected)
			{
				return 0;
			}
			if (ctx.Count <= 0 || !EligibilityTable.IsEligible(ctx.Kind, rules))
			{
				return 0;
			}
			long num = (long)ctx.Count * (long)rules.Multiplier;
			if (num > int.MaxValue)
			{
				num = 2147483647L;
			}
			long val = num - ctx.Count;
			if (rules.StackCap > 0 && !ctx.CapExempt)
			{
				long val2 = rules.StackCap - ((long)ctx.CurrentStack + (long)ctx.Count);
				val = Math.Min(val, Math.Max(0L, val2));
			}
			long val3 = int.MaxValue - ((long)ctx.CurrentStack + (long)ctx.Count);
			return (int)Math.Max(0L, Math.Min(val, val3));
		}
	}
	public readonly struct Recipient
	{
		public int CurrentStack { get; }

		public bool Alive { get; }

		public bool Connected { get; }

		public Recipient(int currentStack, bool alive, bool connected)
		{
			CurrentStack = currentStack;
			Alive = alive;
			Connected = connected;
		}
	}
	public static class SharingPipeline
	{
		public static int[] Resolve(PickupContext ctx, MultiplierRules rules, bool enabled, bool fromSharing, IReadOnlyList<Recipient> others)
		{
			int[] array = new int[others.Count];
			if (!enabled || fromSharing || ctx.Count <= 0 || !EligibilityTable.IsShareable(ctx.Kind))
			{
				return array;
			}
			for (int i = 0; i < others.Count; i++)
			{
				Recipient recipient = others[i];
				if (recipient.Alive && recipient.Connected && !MultiplierPipeline.AtHardCap(recipient.CurrentStack, rules))
				{
					int num = MultiplierPipeline.Resolve(new PickupContext(ctx.Kind, ctx.Count, recipient.CurrentStack, recipient.Alive, recipient.Connected, ctx.CapExempt), rules);
					long num2 = (long)ctx.Count + (long)num;
					array[i] = (int)((num2 > int.MaxValue) ? int.MaxValue : num2);
				}
			}
			return array;
		}
	}
}
namespace Ror2Meeeee.Core.Measurement
{
	public static class FrameStats
	{
		public static void Compute(float[] samples, int count, float[] scratch, out float mean, out float p95)
		{
			if (count <= 0)
			{
				mean = 0f;
				p95 = 0f;
				return;
			}
			double num = 0.0;
			for (int i = 0; i < count; i++)
			{
				num += (double)samples[i];
			}
			mean = (float)(num / (double)count);
			Array.Copy(samples, scratch, count);
			Array.Sort(scratch, 0, count);
			int num2 = (int)Math.Ceiling(0.95 * (double)count);
			p95 = scratch[num2 - 1];
		}
	}
}
namespace Ror2Meeeee.Core.Limits
{
	public static class ChanceAggregate
	{
		public static float Factor(int stack, int capped, float chancePerStack)
		{
			if (capped <= 0 || stack <= capped || chancePerStack <= 0f)
			{
				return 1f;
			}
			float num = Math.Min(100f, chancePerStack * (float)stack);
			float num2 = Math.Min(100f, chancePerStack * (float)capped);
			return num / num2;
		}
	}
	public struct BudgetWindow
	{
		public float Start;

		public int Count;

		public float PendingDamage;
	}
	public static class ProjectileBudget
	{
		public static bool Decide(ref BudgetWindow w, float now, int maxPerSecond, float damage, out float damageToFire)
		{
			if (now - w.Start >= 1f || now < w.Start)
			{
				w.Start = now;
				w.Count = 0;
			}
			if (maxPerSecond <= 0 || w.Count < maxPerSecond)
			{
				w.Count++;
				damageToFire = damage + w.PendingDamage;
				w.PendingDamage = 0f;
				return true;
			}
			w.PendingDamage += damage;
			damageToFire = 0f;
			return false;
		}
	}
	public enum StackMode
	{
		Off,
		Clamp,
		Aggregate
	}
	public interface IStackPolicy
	{
		int Limit { get; }

		int Apply(int stack);
	}
	public static class StackPolicy
	{
		private sealed class OffPolicy : IStackPolicy
		{
			public int Limit => int.MaxValue;

			public int Apply(int stack)
			{
				return stack;
			}
		}

		private sealed class ClampPolicy : IStackPolicy
		{
			private readonly int _limit;

			public int Limit => _limit;

			public ClampPolicy(int limit)
			{
				_limit = limit;
			}

			public int Apply(int stack)
			{
				if (stack >= 0)
				{
					if (stack <= _limit)
					{
						return stack;
					}
					return _limit;
				}
				return 0;
			}
		}

		public static readonly IStackPolicy Off = new OffPolicy();

		public static IStackPolicy Clamp(int limit)
		{
			return new ClampPolicy(Math.Max(1, limit));
		}

		public static IStackPolicy Create(StackMode mode, int limit)
		{
			if (mode != StackMode.Off)
			{
				return Clamp(limit);
			}
			return Off;
		}
	}
}
namespace Ror2Meeeee.Core.Helluva
{
	public static class DropRules
	{
		public static int ClampCount(int requested, int owned, int max)
		{
			if (owned <= 0 || max <= 0)
			{
				return 0;
			}
			return Math.Min(Math.Max(requested, 1), Math.Min(owned, max));
		}
	}
	public static class HelluvaRules
	{
		public static float GrimoireCredit(float baseCredit, float difficultyCoefficient)
		{
			if (float.IsNaN(baseCredit) || baseCredit <= 0f || float.IsNaN(difficultyCoefficient))
			{
				return 0f;
			}
			return (float)Math.Min((double)baseCredit * (double)Math.Max(1f, difficultyCoefficient), 10000000.0);
		}

		public static float GrimoireCreditGuarded(float baseCredit, float difficultyCoefficient, float maxPerUse, int monstersAlive, int maxMonsters)
		{
			if (maxMonsters > 0 && monstersAlive >= maxMonsters)
			{
				return 0f;
			}
			float num = GrimoireCredit(baseCredit, difficultyCoefficient);
			if (!(maxPerUse > 0f))
			{
				return num;
			}
			return Math.Min(num, maxPerUse);
		}

		public static uint ContractGoldCapped(uint goldReward, int teamStacks, uint maxGold)
		{
			uint num = ContractGold(goldReward, teamStacks);
			if (maxGold == 0 || num <= maxGold)
			{
				return num;
			}
			return maxGold;
		}

		public static uint ContractGold(uint goldReward, int teamStacks)
		{
			if (goldReward == 0 || teamStacks <= 0)
			{
				return 0u;
			}
			ulong num = (ulong)(goldReward * teamStacks);
			if (num <= uint.MaxValue)
			{
				return (uint)num;
			}
			return uint.MaxValue;
		}

		public static bool ReviveStep(ref float progress, bool allyNear, float dt, float required)
		{
			if (!allyNear || float.IsNaN(dt) || dt < 0f)
			{
				progress = 0f;
				return false;
			}
			progress += dt;
			if (progress < required)
			{
				return false;
			}
			progress = 0f;
			return true;
		}

		public static float ReviverCost(float currentHealth, float fraction)
		{
			if (float.IsNaN(currentHealth) || currentHealth <= 1f || float.IsNaN(fraction) || fraction <= 0f)
			{
				return 0f;
			}
			return Math.Min(currentHealth * Math.Min(1f, fraction), currentHealth - 1f);
		}
	}
}
namespace Ror2Meeeee.Core.Gold
{
	public static class GoldCredit
	{
		public static float Compute(uint amount, int stacks, float ratioPerStack)
		{
			if (amount == 0 || stacks <= 0 || float.IsNaN(ratioPerStack) || float.IsInfinity(ratioPerStack) || ratioPerStack <= 0f)
			{
				return 0f;
			}
			return (float)Math.Min((double)amount * (double)stacks * (double)ratioPerStack, 3.4028234663852886E+38);
		}
	}
	public static class TitheThanks
	{
		private static readonly string[] Lines = new string[4] { "Obrigado pelo dízimo! R$ {1} de vocês já viraram {0} de crédito em monstro.", "Sua generosidade foi notada: R$ {1} viraram +{0} de crédito de spawn.", "R$ {1} recolhidos, {0} de crédito investido em companhia para vocês.", "O diretor agradece a contribuição de R$ {1}. Os monstros também ({0} de crédito)." };

		public static bool Due(double now, double lastPost, double interval, double pendingCredit)
		{
			if (interval > 0.0 && pendingCredit >= 1.0)
			{
				return now - lastPost >= interval;
			}
			return false;
		}

		public static string Format(int index, double credit, ulong gold)
		{
			CultureInfo invariantCulture = CultureInfo.InvariantCulture;
			string format = Lines[(uint)index % (uint)Lines.Length];
			return "<color=#c792ea>Diretor:</color> " + string.Format(invariantCulture, format, Thousands(Math.Floor(credit).ToString("N0", invariantCulture)), Thousands(gold.ToString("N0", invariantCulture)));
		}

		private static string Thousands(string invariantN0)
		{
			return invariantN0.Replace(',', '.');
		}
	}
}
namespace Ror2Meeeee.Core.Elites
{
	public static class EliteRules
	{
		public static (int First, int Second) PickTwoDistinct(int count, int a, int b)
		{
			if (count < 1)
			{
				return (First: -1, Second: -1);
			}
			if (count < 2)
			{
				return (First: 0, Second: -1);
			}
			return (First: a, Second: (b >= a) ? (b + 1) : b);
		}
	}
}
namespace Ror2Meeeee.Core.Eligibility
{
	public enum ItemKind
	{
		White,
		Green,
		Red,
		Boss,
		Lunar,
		Void,
		Temporary,
		Scrap,
		Equipment,
		Other,
		Special
	}
	public static class EligibilityTable
	{
		public static bool IsEligible(ItemKind kind, MultiplierRules rules)
		{
			switch (kind)
			{
			case ItemKind.White:
			case ItemKind.Green:
			case ItemKind.Red:
			case ItemKind.Boss:
				return true;
			case ItemKind.Lunar:
				return rules.IncludeLunar;
			case ItemKind.Void:
				return rules.IncludeVoid;
			default:
				return false;
			}
		}

		public static bool IsShareable(ItemKind kind)
		{
			if (kind != ItemKind.Equipment)
			{
				return kind != ItemKind.Other;
			}
			return false;
		}
	}
}
namespace Ror2Meeeee.Core.Difficulty
{
	public readonly struct DifficultyGains
	{
		public float Health { get; }

		public float Damage { get; }

		public float Quantity { get; }

		public float Pace { get; }

		public DifficultyGains(float health, float damage, float quantity, float pace)
		{
			Health = health;
			Damage = damage;
			Quantity = quantity;
			Pace = pace;
		}
	}
	public readonly struct DifficultyMultipliers
	{
		public static readonly DifficultyMultipliers Identity = new DifficultyMultipliers(1f, 1f, 1f, 1f);

		public float Health { get; }

		public float Damage { get; }

		public float Quantity { get; }

		public float Pace { get; }

		public DifficultyMultipliers(float health, float damage, float quantity, float pace)
		{
			Health = health;
			Damage = damage;
			Quantity = quantity;
			Pace = pace;
		}
	}
	public static class DifficultyCurve
	{
		public const float DefaultFactor = 1f;

		public const float MinMultiplier = 0.1f;

		public const float MaxMultiplier = 1000f;

		public static float SanitizeFactor(float factor)
		{
			if (float.IsNaN(factor) || float.IsInfinity(factor) || factor <= 0f)
			{
				return 1f;
			}
			return factor;
		}

		public static DifficultyMultipliers Evaluate(float factor, DifficultyGains gains)
		{
			float factor2 = SanitizeFactor(factor);
			return new DifficultyMultipliers(Axis(factor2, gains.Health), Axis(factor2, gains.Damage), Axis(factor2, gains.Quantity), Axis(factor2, gains.Pace));
		}

		public static float WithBonus(float multiplier, float bonusPercent)
		{
			if (float.IsNaN(bonusPercent) || float.IsInfinity(bonusPercent))
			{
				bonusPercent = 0f;
			}
			double val = (double)multiplier * (1.0 + (double)bonusPercent / 100.0);
			return (float)Math.Min(1000.0, Math.Max(0.10000000149011612, val));
		}

		private static float Axis(float factor, float gain)
		{
			if (float.IsNaN(gain) || float.IsInfinity(gain))
			{
				return 1f;
			}
			double val = 1.0 + ((double)factor - 1.0) * (double)gain;
			return (float)Math.Min(1000.0, Math.Max(0.10000000149011612, val));
		}
	}
	public static class HordeCurve
	{
		public static float QuantityMultiplier(int stacks, float perStack, float max)
		{
			if (stacks <= 0 || float.IsNaN(perStack) || float.IsNaN(max) || perStack <= 0f || max < 1f)
			{
				return 1f;
			}
			double val = 1.0 + (double)stacks * (double)perStack;
			return (float)Math.Min(max, val);
		}
	}
}
namespace Ror2Meeeee.Core.Bazaar
{
	public enum BazaarTier
	{
		White,
		Green,
		Red,
		Boss,
		Lunar,
		Equipment,
		LunarEquipment
	}
	public static class BazaarRules
	{
		public const int TierCount = 7;

		public const int MaxChests = 6;

		public const int SmallChestBaseCost = 25;

		public const int Unlimited = -1;

		public static int PickWeighted(IReadOnlyList<float> weights, double roll)
		{
			double num = 0.0;
			for (int i = 0; i < weights.Count; i++)
			{
				num += Valid(weights[i]);
			}
			if (num <= 0.0)
			{
				return -1;
			}
			double num2 = roll * num;
			int result = -1;
			for (int j = 0; j < weights.Count; j++)
			{
				double num3 = Valid(weights[j]);
				if (!(num3 <= 0.0))
				{
					if (num2 < num3)
					{
						return j;
					}
					num2 -= num3;
					result = j;
				}
			}
			return result;
		}

		public static int ScaledCost(int baseCost, float difficultyCoefficient, float multiplier)
		{
			double x = ((float.IsNaN(difficultyCoefficient) || difficultyCoefficient <= 0f) ? 1f : difficultyCoefficient);
			double num = ((float.IsNaN(multiplier) || multiplier < 0f) ? 0f : multiplier);
			double num2 = (double)Math.Max(0, baseCost) * Math.Pow(x, 1.25) * num;
			if (!(num2 >= 2147483647.0))
			{
				return (int)num2;
			}
			return int.MaxValue;
		}

		public static int GoldCost(float difficultyCoefficient, float multiplier)
		{
			return ScaledCost(25, difficultyCoefficient, multiplier);
		}

		public static bool UnderLimit(int used, int limit)
		{
			if (limit >= 0)
			{
				return used < limit;
			}
			return true;
		}

		public static int ClampChests(int n)
		{
			if (n >= 1)
			{
				if (n <= 6)
				{
					return n;
				}
				return 6;
			}
			return 1;
		}

		public static uint AddMoney(uint money, long amount)
		{
			long num = money + amount;
			if (num > 0)
			{
				if (num < uint.MaxValue)
				{
					return (uint)num;
				}
				return uint.MaxValue;
			}
			return 0u;
		}

		private static double Valid(float w)
		{
			return (float.IsNaN(w) || w <= 0f) ? 0f : w;
		}
	}
}
namespace Ror2Meeeee.Core.Aegis
{
	public static class AegisRules
	{
		public const float BlockChancePercent = 5f;

		public const float StealPerStack = 0.08f;

		public const float StealCap = 0.5f;

		public const float VoidPerStack = 0.03f;

		public const float VoidCap = 0.2f;

		public const float VoidBaseRadius = 13f;

		public const float VoidRadiusPerStack = 2f;

		public const float VoidRadiusCap = 30f;

		public static float StealFraction(int stacks)
		{
			return Capped(0.08f * (float)stacks, stacks, 0.5f);
		}

		public static float VoidFraction(int stacks)
		{
			return Capped(0.03f * (float)stacks, stacks, 0.2f);
		}

		public static float VoidRadius(int stacks)
		{
			if (stacks <= 0)
			{
				return 0f;
			}
			float num = 13f + 2f * (float)(stacks - 1);
			if (!(num < 30f))
			{
				return 30f;
			}
			return num;
		}

		private static float Capped(float value, int stacks, float cap)
		{
			if (stacks > 0)
			{
				if (!(value < cap))
				{
					return cap;
				}
				return value;
			}
			return 0f;
		}
	}
}