Decompiled source of RoguelikeDebugger v0.1.4

plugins/RoguelikeDebugger/RoguelikeDebugger.dll

Decompiled a month ago
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using BepInEx;
using BepInEx.Logging;
using Burst2Flame;
using Burst2Flame.Observable;
using HarmonyLib;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("RoguelikeDebugger")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Logs de investigação de mecânicas do Stolen Realm (loot, Gold, Experience, eventos).")]
[assembly: AssemblyFileVersion("0.1.4.0")]
[assembly: AssemblyInformationalVersion("0.1.4")]
[assembly: AssemblyProduct("RoguelikeDebugger")]
[assembly: AssemblyTitle("RoguelikeDebugger")]
[assembly: AssemblyVersion("0.1.4.0")]
namespace RoguelikeDebugger
{
	internal static class EfeitosInfo
	{
		private static readonly Dictionary<string, int> Contagem = new Dictionary<string, int>();

		private static int _total;

		private static int _naoGeneralEffect;

		public static void Zerar()
		{
			Contagem.Clear();
			_total = 0;
			_naoGeneralEffect = 0;
		}

		public static string Resumo()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("total=").Append(_total);
			stringBuilder.Append(" | porTipo={");
			bool flag = true;
			List<string> list = new List<string>(Contagem.Keys);
			list.Sort(StringComparer.Ordinal);
			foreach (string item in list)
			{
				if (!flag)
				{
					stringBuilder.Append("; ");
				}
				flag = false;
				stringBuilder.Append(item).Append('=').Append(Contagem[item]);
			}
			stringBuilder.Append("}");
			stringBuilder.Append(" | naoGeneralEffect=").Append(_naoGeneralEffect);
			return stringBuilder.ToString();
		}

		public static int Conta(Array arr)
		{
			return arr?.Length ?? 0;
		}

		public static string Nomes<T>(T[] arr) where T : Object
		{
			if (arr == null || arr.Length == 0)
			{
				return "";
			}
			StringBuilder stringBuilder = new StringBuilder();
			foreach (T val in arr)
			{
				if ((Object)(object)val != (Object)null && !string.IsNullOrEmpty(((Object)val).name))
				{
					stringBuilder.Append(Limpa(((Object)val).name)).Append("; ");
				}
			}
			return stringBuilder.ToString().TrimEnd(' ', ';');
		}

		public static string Nome(Object o)
		{
			if (!(o == (Object)null))
			{
				return Limpa(o.name);
			}
			return "";
		}

		public static string Junta(string[] itens)
		{
			if (itens == null || itens.Length == 0)
			{
				return "";
			}
			StringBuilder stringBuilder = new StringBuilder();
			foreach (string text in itens)
			{
				if (!string.IsNullOrEmpty(text))
				{
					stringBuilder.Append(Limpa(text)).Append("; ");
				}
			}
			return stringBuilder.ToString().TrimEnd(' ', ';');
		}

		public static string Descreve(Array arr)
		{
			return DescreveCore(arr, origemIEffectInfo: false);
		}

		public static string Descreve(IEffectInfo[] arr)
		{
			return DescreveCore(arr, origemIEffectInfo: true);
		}

		private static string DescreveCore(Array arr, bool origemIEffectInfo)
		{
			if (arr == null || arr.Length == 0)
			{
				return "";
			}
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = 0; i < arr.Length; i++)
			{
				object value;
				try
				{
					value = arr.GetValue(i);
				}
				catch (Exception ex)
				{
					value = null;
					stringBuilder.Append(i).Append(":<erro:").Append(ex.GetType().Name)
						.Append(">; ");
					continue;
				}
				stringBuilder.Append(i).Append(':').Append(Um(value, origemIEffectInfo))
					.Append("; ");
			}
			return stringBuilder.ToString().TrimEnd(' ', ';');
		}

		private static string Um(object o, bool origemIEffectInfo)
		{
			if (o == null)
			{
				Contagem["null"] = ((!Contagem.TryGetValue("null", out var value)) ? 1 : (value + 1));
				_total++;
				return "null";
			}
			Type type = o.GetType();
			string name = type.Name;
			Contagem[name] = ((!Contagem.TryGetValue(name, out var value2)) ? 1 : (value2 + 1));
			_total++;
			if (origemIEffectInfo && !(o is GeneralEffect))
			{
				_naoGeneralEffect++;
			}
			FieldInfo[] array;
			try
			{
				array = type.GetFields(BindingFlags.Instance | BindingFlags.Public);
			}
			catch (Exception)
			{
				array = new FieldInfo[0];
			}
			Array.Sort(array, (FieldInfo a, FieldInfo b) => string.CompareOrdinal(a.Name, b.Name));
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(name).Append('{');
			bool flag = true;
			FieldInfo[] array2 = array;
			foreach (FieldInfo fieldInfo in array2)
			{
				if (!fieldInfo.IsStatic)
				{
					object v;
					try
					{
						v = fieldInfo.GetValue(o);
					}
					catch (Exception ex2)
					{
						v = "<erro:" + ex2.GetType().Name + ">";
					}
					if (!flag)
					{
						stringBuilder.Append(';');
					}
					flag = false;
					stringBuilder.Append(fieldInfo.Name).Append('=').Append(Valor(v));
				}
			}
			stringBuilder.Append('}');
			return stringBuilder.ToString();
		}

		private static string Valor(object v)
		{
			if (v == null)
			{
				return "-";
			}
			Object val = (Object)((v is Object) ? v : null);
			if (val != (Object)null)
			{
				return Limpa(val.name);
			}
			if (v is string text)
			{
				if (text.Length != 0)
				{
					return Limpa(text);
				}
				return "-";
			}
			if (v is Array array)
			{
				return "[" + array.Length + "]";
			}
			return Limpa(v.ToString());
		}

		public static string Limpa(string s)
		{
			return (s ?? "").Replace("\n", " ").Replace("\r", " ").Replace("|", "/")
				.Replace("\"", "'")
				.Trim();
		}
	}
	[BepInPlugin("com.gumatos.roguelikedebugger", "Roguelike Debugger", "0.1.4")]
	public class Plugin : BaseUnityPlugin
	{
		private sealed class ResumoGanchos
		{
			internal int Total;

			internal int Ok;

			internal int Metodos;

			internal readonly List<string> Falhas = new List<string>();

			internal readonly List<string> Aplicados = new List<string>();

			internal bool Aplicado(string nome)
			{
				return Aplicados.Contains(nome);
			}
		}

		internal static ManualLogSource Log { get; private set; }

		private void Awake()
		{
			Log = ((BaseUnityPlugin)this).Logger;
			Proveniencia.Cabecalho();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Roguelike Debugger carregado.");
			ResumoGanchos resumoGanchos = AplicarPatches();
			Proveniencia.Estado(resumoGanchos.Ok, resumoGanchos.Total, resumoGanchos.Metodos, resumoGanchos.Falhas, resumoGanchos.Aplicado("FlameEvalVoidPatch"));
			Application.quitting += AoFechar;
		}

		private static void AoFechar()
		{
			Proveniencia.Fim("saida-do-jogo");
		}

		private static ResumoGanchos AplicarPatches()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			ResumoGanchos resumoGanchos = new ResumoGanchos();
			Harmony val = new Harmony("com.gumatos.roguelikedebugger");
			List<string> falhas = resumoGanchos.Falhas;
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			Type[] types;
			try
			{
				types = typeof(Plugin).Assembly.GetTypes();
			}
			catch (Exception ex)
			{
				Log.LogError((object)("Roguelike Debugger: nao deu para listar os tipos do mod — nenhum gancho aplicado: " + ex));
				return resumoGanchos;
			}
			foreach (Type type in types)
			{
				if (EhClasseDeGancho(type))
				{
					num++;
					try
					{
						int num4 = val.CreateClassProcessor(type).Patch()?.Count ?? 0;
						num3 += num4;
						num2++;
						resumoGanchos.Aplicados.Add(type.Name);
						Log.LogInfo((object)("Roguelike Debugger: gancho aplicado — " + type.Name + " (" + num4 + " metodo(s) do jogo)."));
					}
					catch (Exception ex2)
					{
						falhas.Add(type.Name);
						Log.LogError((object)("Roguelike Debugger: FALHA ao aplicar o gancho " + type.Name + " — " + ex2.Message));
					}
				}
			}
			string text = "Roguelike Debugger: patches Harmony aplicados (" + num2 + "/" + num + " ganchos, " + num3 + " metodos do jogo).";
			resumoGanchos.Total = num;
			resumoGanchos.Ok = num2;
			resumoGanchos.Metodos = num3;
			if (falhas.Count == 0)
			{
				Log.LogInfo((object)text);
				return resumoGanchos;
			}
			Log.LogError((object)(text + " GANCHOS QUE FALHARAM: " + string.Join(", ", falhas.ToArray()) + ". O mod continua de pe, mas o log do recurso que dependia deles nao sai nesta sessao."));
			return resumoGanchos;
		}

		private static bool EhClasseDeGancho(Type tipo)
		{
			try
			{
				if (tipo == null || !tipo.IsClass)
				{
					return false;
				}
				return tipo.GetCustomAttributes(typeof(HarmonyPatch), inherit: false).Length != 0;
			}
			catch (Exception)
			{
				return false;
			}
		}
	}
	internal static class Proveniencia
	{
		private sealed class Sonda
		{
			internal string Identidade = "local";

			internal bool Presente;

			internal string EnableHooks = "desconhecido";

			internal string Versao = "-";

			internal string Sha256 = "-";

			internal string BuildSteam = "desconhecido";

			internal string Conforme = "indeterminado";
		}

		internal const string Marca = "DBG-PROV-V1";

		internal const string Aparelho = "[Proveniencia]";

		internal const string Desconhecido = "desconhecido";

		private const string Alvo = "Assembly-CSharp";

		private const int AppIdSteam = 1330000;

		internal static void Cabecalho()
		{
			List<string> list = new List<string>();
			try
			{
				string text = VersaoDoJogo();
				string text2 = Sha256DoAlvo();
				Sonda sonda = SondaApi(text, text2);
				list.Add("versaoJogo=" + Texto(text));
				list.Add("buildSteam=" + Texto((sonda.Identidade == "api") ? sonda.BuildSteam : BuildSteam()));
				list.Add("sha256Alvo=" + Texto(text2));
				list.Add("dllDebugger=" + NomeDll() + "@" + VersaoDll());
				list.Add("sha256Dll=" + Texto(Sha256DaPropriaDll()));
				list.Add("identidade=" + sonda.Identidade);
				list.Add("apiPresente=" + SimNao(sonda.Presente));
				list.Add("apiEnableHooks=" + sonda.EnableHooks);
				list.Add("apiVersao=" + sonda.Versao);
				list.Add("apiSha256=" + sonda.Sha256);
				list.Add("alvoConforme=" + sonda.Conforme);
				list.Add("inicioEm=" + DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ssZ", CultureInfo.InvariantCulture));
				list.Add("estadoDump=INICIADO");
			}
			catch (Exception ex)
			{
				list.Add("erroDeteccao=!erro:" + ex.GetType().Name);
				list.Add("estadoDump=INICIADO");
			}
			Emitir("inicio", list);
		}

		internal static void Estado(int ganchosOk, int ganchosTotal, int metodos, IList<string> falhas, bool matrizFlame)
		{
			List<string> list = new List<string>();
			try
			{
				bool flag = falhas != null && falhas.Count > 0;
				list.Add("estadoDump=" + (flag ? "PARCIAL" : "ABERTO"));
				list.Add("ganchosOk=" + ganchosOk + "/" + ganchosTotal);
				list.Add("ganchosFalhos=" + (flag ? string.Join(",", falhas.ToArray()) : "nenhum"));
				list.Add("metodos=" + metodos);
				list.Add("matrizFlame=" + (matrizFlame ? "aplicada" : "ausente"));
				list.Add("modoLeitura=" + (matrizFlame ? "ativo" : "passivo"));
			}
			catch (Exception ex)
			{
				list.Add("erroDeteccao=!erro:" + ex.GetType().Name);
				list.Add("estadoDump=PARCIAL");
			}
			Emitir("estado", list);
		}

		internal static void Fim(string motivo)
		{
			Emitir("fim", new List<string>
			{
				"estadoDump=FECHADO",
				"motivo=" + Texto(motivo)
			});
		}

		private static void Emitir(string fase, IList<string> campos)
		{
			try
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.Append("[Proveniencia]").Append(' ').Append("DBG-PROV-V1")
					.Append(' ')
					.Append(fase);
				for (int i = 0; i < campos.Count; i++)
				{
					stringBuilder.Append(" | ").Append(campos[i]);
				}
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)stringBuilder.ToString());
				}
			}
			catch (Exception)
			{
			}
		}

		private static string VersaoDoJogo()
		{
			try
			{
				string version = Application.version;
				return string.IsNullOrWhiteSpace(version) ? "desconhecido" : version.Trim();
			}
			catch (Exception)
			{
				return "desconhecido";
			}
		}

		private static string Sha256DoAlvo()
		{
			try
			{
				Assembly assembly = null;
				Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
				for (int i = 0; i < assemblies.Length; i++)
				{
					if (string.Equals(assemblies[i].GetName().Name, "Assembly-CSharp", StringComparison.Ordinal))
					{
						assembly = assemblies[i];
						break;
					}
				}
				if (assembly == null || string.IsNullOrEmpty(assembly.Location))
				{
					return "desconhecido";
				}
				return Sha256DeArquivo(assembly.Location);
			}
			catch (Exception)
			{
				return "desconhecido";
			}
		}

		private static string Sha256DaPropriaDll()
		{
			try
			{
				string location = typeof(Plugin).Assembly.Location;
				return string.IsNullOrEmpty(location) ? "desconhecido" : Sha256DeArquivo(location);
			}
			catch (Exception)
			{
				return "desconhecido";
			}
		}

		private static string Sha256DeArquivo(string caminho)
		{
			using SHA256 sHA = SHA256.Create();
			using FileStream inputStream = File.OpenRead(caminho);
			byte[] array = sHA.ComputeHash(inputStream);
			StringBuilder stringBuilder = new StringBuilder(array.Length * 2);
			for (int i = 0; i < array.Length; i++)
			{
				stringBuilder.Append(array[i].ToString("x2", CultureInfo.InvariantCulture));
			}
			return stringBuilder.ToString();
		}

		private static string BuildSteam()
		{
			try
			{
				string text = RaizDoJogo();
				if (string.IsNullOrEmpty(text))
				{
					return "desconhecido";
				}
				string path = Path.Combine(Path.GetFullPath(Path.Combine(text, "..", "..")), "appmanifest_" + 1330000 + ".acf");
				if (!File.Exists(path))
				{
					return "desconhecido";
				}
				string[] array = File.ReadAllLines(path);
				for (int i = 0; i < array.Length; i++)
				{
					string text2 = array[i].Trim();
					if (!text2.StartsWith("\"buildid\"", StringComparison.Ordinal))
					{
						continue;
					}
					int num = text2.IndexOf('"', 1);
					if (num >= 0)
					{
						int num2 = text2.IndexOf('"', num + 1);
						if (num2 >= 0)
						{
							string text3 = text2.Substring(num + 1, num2 - num - 1).Trim();
							return string.IsNullOrEmpty(text3) ? "desconhecido" : text3;
						}
					}
				}
				return "desconhecido";
			}
			catch (Exception)
			{
				return "desconhecido";
			}
		}

		private static string RaizDoJogo()
		{
			try
			{
				string gameRootPath = Paths.GameRootPath;
				if (!string.IsNullOrEmpty(gameRootPath) && Directory.Exists(gameRootPath))
				{
					return gameRootPath;
				}
			}
			catch (Exception)
			{
			}
			try
			{
				string dataPath = Application.dataPath;
				if (!string.IsNullOrEmpty(dataPath))
				{
					string directoryName = Path.GetDirectoryName(dataPath);
					if (!string.IsNullOrEmpty(directoryName) && Directory.Exists(directoryName))
					{
						return directoryName;
					}
				}
			}
			catch (Exception)
			{
			}
			return null;
		}

		private static string NomeDll()
		{
			try
			{
				return Texto(typeof(Plugin).Assembly.GetName().Name);
			}
			catch (Exception)
			{
				return "desconhecido";
			}
		}

		private static string VersaoDll()
		{
			try
			{
				Assembly assembly = typeof(Plugin).Assembly;
				AssemblyInformationalVersionAttribute assemblyInformationalVersionAttribute = (AssemblyInformationalVersionAttribute)Attribute.GetCustomAttribute(assembly, typeof(AssemblyInformationalVersionAttribute));
				if (assemblyInformationalVersionAttribute != null && !string.IsNullOrWhiteSpace(assemblyInformationalVersionAttribute.InformationalVersion))
				{
					return assemblyInformationalVersionAttribute.InformationalVersion.Trim();
				}
				Version version = assembly.GetName().Version;
				return (version == null) ? "desconhecido" : version.ToString();
			}
			catch (Exception)
			{
				return "desconhecido";
			}
		}

		private static Sonda SondaApi(string versaoMedida, string shaMedido)
		{
			Sonda sonda = new Sonda();
			try
			{
				Type type = null;
				Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
				for (int i = 0; i < assemblies.Length; i++)
				{
					if (!(type == null))
					{
						break;
					}
					try
					{
						type = assemblies[i].GetType("Gumatos.RealmApi.ApiIdentity", throwOnError: false, ignoreCase: false);
					}
					catch (Exception)
					{
					}
				}
				if (type == null)
				{
					return sonda;
				}
				sonda.Presente = true;
				sonda.Versao = Texto(Constante(type, "Version"));
				sonda.Sha256 = Texto(Constante(type, "AssemblySha256"));
				sonda.BuildSteam = Texto(Constante(type, "SteamBuildId"));
				sonda.EnableHooks = EnableHooksDaApi();
				sonda.Conforme = MatchesDaApi(type, versaoMedida, shaMedido);
				if (string.Equals(sonda.EnableHooks, "sim", StringComparison.Ordinal))
				{
					sonda.Identidade = "api";
				}
				return sonda;
			}
			catch (Exception ex2)
			{
				sonda.Conforme = "indeterminado";
				sonda.Versao = ((sonda.Versao == "-") ? ("!erro:" + ex2.GetType().Name) : sonda.Versao);
				return sonda;
			}
		}

		private static string Constante(Type tipo, string nome)
		{
			try
			{
				FieldInfo field = tipo.GetField(nome, BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy);
				if (field == null)
				{
					return "desconhecido";
				}
				object obj;
				try
				{
					obj = field.GetRawConstantValue();
				}
				catch (Exception)
				{
					obj = field.GetValue(null);
				}
				return (obj == null) ? "desconhecido" : Convert.ToString(obj, CultureInfo.InvariantCulture);
			}
			catch (Exception)
			{
				return "desconhecido";
			}
		}

		private static string MatchesDaApi(Type tipo, string versao, string sha)
		{
			try
			{
				MethodInfo method = tipo.GetMethod("Matches", BindingFlags.Static | BindingFlags.Public, null, new Type[2]
				{
					typeof(string),
					typeof(string)
				}, null);
				if (method == null)
				{
					return "indeterminado";
				}
				object obj = method.Invoke(null, new object[2] { versao, sha });
				if (obj is bool)
				{
					return ((bool)obj) ? "sim" : "nao";
				}
				return "indeterminado";
			}
			catch (Exception)
			{
				return "indeterminado";
			}
		}

		private static string EnableHooksDaApi()
		{
			try
			{
				string path = Path.Combine(Paths.ConfigPath, "com.gumatos.realmapi.cfg");
				if (!File.Exists(path))
				{
					return "desconhecido";
				}
				string[] array = File.ReadAllLines(path);
				for (int i = 0; i < array.Length; i++)
				{
					string text = array[i].Trim();
					if (text.StartsWith("#", StringComparison.Ordinal))
					{
						continue;
					}
					int num = text.IndexOf('=');
					if (num > 0 && string.Equals(text.Substring(0, num).Trim(), "EnableHooks", StringComparison.OrdinalIgnoreCase))
					{
						string text2 = text.Substring(num + 1).Trim();
						if (text2.Equals("true", StringComparison.OrdinalIgnoreCase))
						{
							return "sim";
						}
						if (text2.Equals("false", StringComparison.OrdinalIgnoreCase))
						{
							return "nao";
						}
						return "desconhecido";
					}
				}
				return "desconhecido";
			}
			catch (Exception)
			{
				return "desconhecido";
			}
		}

		private static string Texto(string valor)
		{
			if (!string.IsNullOrWhiteSpace(valor))
			{
				return valor.Trim();
			}
			return "desconhecido";
		}

		private static string SimNao(bool valor)
		{
			if (!valor)
			{
				return "nao";
			}
			return "sim";
		}
	}
}
namespace RoguelikeDebugger.Patches
{
	[HarmonyPatch(typeof(Game), "get_ActionStatuses")]
	public static class ActionStatusInventoryPatch
	{
		private static bool _dumped;

		private static int _lastCount = -1;

		private static int _stableHits;

		private static string TriggersDe(ActionStatusInfo s)
		{
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)s == (Object)null || s.SkillTriggers == null || s.SkillTriggers.Length == 0)
			{
				return "";
			}
			StringBuilder stringBuilder = new StringBuilder();
			SkillTrigger[] skillTriggers = s.SkillTriggers;
			foreach (SkillTrigger val in skillTriggers)
			{
				if (val == null)
				{
					continue;
				}
				StringBuilder stringBuilder2 = new StringBuilder();
				if (val.ActionStatuses != null)
				{
					ActionStatusInfo[] actionStatuses = val.ActionStatuses;
					foreach (ActionStatusInfo val2 in actionStatuses)
					{
						if ((Object)(object)val2 != (Object)null)
						{
							stringBuilder2.Append(EfeitosInfo.Limpa(val2.Name)).Append(',');
						}
					}
				}
				StringBuilder stringBuilder3 = new StringBuilder();
				if (val.Actions != null)
				{
					ActionInfo[] actions = val.Actions;
					foreach (ActionInfo val3 in actions)
					{
						if (!((Object)(object)val3 == (Object)null))
						{
							stringBuilder3.Append(EfeitosInfo.Limpa(((Object)val3).name)).Append("{ef=").Append(EfeitosInfo.Descreve(val3.Effects))
								.Append("}; ");
						}
					}
				}
				StringBuilder stringBuilder4 = stringBuilder.Append(val.TriggerType).Append("[ef=");
				IEffectInfo[] generalEffects = (IEffectInfo[])(object)val.GeneralEffects;
				stringBuilder4.Append(EfeitosInfo.Descreve(generalEffects)).Append("~cond=").Append(EfeitosInfo.Limpa(val.Condition))
					.Append("~status=")
					.Append(stringBuilder2)
					.Append("~alvos=")
					.Append(EfeitosInfo.Limpa(val.Targets))
					.Append("~acoes=")
					.Append(stringBuilder3.ToString().TrimEnd(' ', ';'))
					.Append("~chances=")
					.Append(EfeitosInfo.Junta(val.ActionChanceEquations))
					.Append("~cd=")
					.Append(val.Cooldown)
					.Append("]; ");
			}
			return stringBuilder.ToString().TrimEnd(' ', ';');
		}

		private static string TickDe(ActionStatusInfo s)
		{
			bool num = !string.IsNullOrEmpty(s.TickTargets);
			bool flag = !string.IsNullOrEmpty(s.ActionsOnTickCondition);
			bool flag2 = !string.IsNullOrEmpty(s.ActionsOnTickTargets);
			bool flag3 = s.ActionsOnTick != null && s.ActionsOnTick.Length != 0;
			bool flag4 = !string.IsNullOrEmpty(s.StatusEffectsOnTickCondition);
			bool flag5 = !string.IsNullOrEmpty(s.StatusEffectsOnTickTargets);
			bool flag6 = s.StatusEffectsOnTick != null && s.StatusEffectsOnTick.Length != 0;
			if (!(num || flag || flag2 || flag3 || flag4 || flag5 || flag6))
			{
				return "-";
			}
			StringBuilder stringBuilder = new StringBuilder();
			if (s.ActionsOnTick != null)
			{
				ActionInfo[] actionsOnTick = s.ActionsOnTick;
				foreach (ActionInfo val in actionsOnTick)
				{
					if (!((Object)(object)val == (Object)null))
					{
						stringBuilder.Append(EfeitosInfo.Limpa(((Object)val).name)).Append("{ef=").Append(EfeitosInfo.Descreve(val.Effects))
							.Append("}; ");
					}
				}
			}
			return "[alvos=" + EfeitosInfo.Limpa(s.TickTargets) + ";cond=" + EfeitosInfo.Limpa(s.ActionsOnTickCondition) + ";alvoAcoes=" + EfeitosInfo.Limpa(s.ActionsOnTickTargets) + ";acoes=" + stringBuilder.ToString().TrimEnd(' ', ';') + ";proc=" + (s.ActionsOnTickProcTriggers ? "sim" : "nao") + ";status=" + EfeitosInfo.Nomes<ActionStatusInfo>(s.StatusEffectsOnTick) + ";statusCond=" + EfeitosInfo.Limpa(s.StatusEffectsOnTickCondition) + ";statusAlvos=" + EfeitosInfo.Limpa(s.StatusEffectsOnTickTargets) + ";nStatusOv=" + ((s.StatusEffectsOnTickOverrides != null) ? s.StatusEffectsOnTickOverrides.Length : 0) + "]";
		}

		private static string AuraDe(ActionStatusInfo s)
		{
			int num = ((s.AuraTriggerStatusOverrides != null) ? s.AuraTriggerStatusOverrides.Length : 0);
			if ((Object)(object)s.AuraSourceStatus == (Object)null && (Object)(object)s.AuraTriggerStatus == (Object)null && num == 0)
			{
				return "-";
			}
			return "[fonte=" + EfeitosInfo.Nome((Object)(object)s.AuraSourceStatus) + ";gatilho=" + EfeitosInfo.Nome((Object)(object)s.AuraTriggerStatus) + ";nGatilhoOv=" + num + "]";
		}

		private static string Campo(string nome, Func<string> ler)
		{
			try
			{
				return ler();
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[Status] campo '" + nome + "' falhou (" + ex.GetType().Name + ": " + ex.Message + ") - o campo sai como marcador e o dump SEGUE."));
				return "!erro:" + ex.GetType().Name;
			}
		}

		private static void Postfix(List<ActionStatusInfo> __result)
		{
			try
			{
				if (_dumped || __result == null || __result.Count <= 1)
				{
					return;
				}
				if (__result.Count == _lastCount)
				{
					_stableHits++;
				}
				else
				{
					_stableHits = 1;
					_lastCount = __result.Count;
				}
				if (_stableHits < 5)
				{
					return;
				}
				_dumped = true;
				Plugin.Log.LogInfo((object)$"[Status] Inventário: {__result.Count} status carregados.");
				EfeitosInfo.Zerar();
				foreach (ActionStatusInfo s in new List<ActionStatusInfo>(__result))
				{
					if ((Object)(object)s == (Object)null)
					{
						continue;
					}
					string text = Campo("nome", () => s.Name);
					string text2 = Campo("tipo", () => ((object)Unsafe.As<StatusType, StatusType>(ref s.StatusType)/*cast due to .constrained prefix*/).ToString());
					string text3 = Campo("raridade", () => ((object)Unsafe.As<ItemQuality, ItemQuality>(ref s.Rarity)/*cast due to .constrained prefix*/).ToString());
					string text4 = Campo("desc", () => (s.Description ?? "").Replace("\n", " "));
					string arg = Campo("efeitos", delegate
					{
						//IL_0051: Unknown result type (might be due to invalid IL or missing references)
						StringBuilder stringBuilder = new StringBuilder();
						if (s.AttributeEffects != null)
						{
							CharacterEffectInfo[] attributeEffects = s.AttributeEffects;
							foreach (CharacterEffectInfo val in attributeEffects)
							{
								if (val != null && !((Object)(object)val.CharacterAttribute == (Object)null))
								{
									stringBuilder.Append(((Object)val.CharacterAttribute).name).Append(':').Append(val.CharacterEffectMethod)
										.Append(':')
										.Append(val.Amount)
										.Append(", ");
								}
							}
						}
						return stringBuilder.ToString();
					});
					int nGerais = 0;
					string arg2 = Campo("efeitosDano", delegate
					{
						StringBuilder stringBuilder = new StringBuilder();
						nGerais = 0;
						if (s.Effects != null)
						{
							IEffectInfo[] effects = s.Effects;
							foreach (IEffectInfo obj in effects)
							{
								GeneralEffect val = (GeneralEffect)(object)((obj is GeneralEffect) ? obj : null);
								if (val != null)
								{
									nGerais++;
									if (!string.IsNullOrEmpty(val.Action))
									{
										stringBuilder.Append(val.Action.Replace("\n", " ").Replace("\r", " ").Replace("|", "/")
											.Replace("\"", "'")
											.Trim()).Append("; ");
									}
								}
							}
						}
						return stringBuilder.ToString();
					});
					string text5 = Campo("efTipos", () => EfeitosInfo.Descreve(s.Effects));
					string text6 = Campo("attrTipos", () => EfeitosInfo.Descreve(s.AttributeEffects));
					string text7 = Campo("modelo", delegate
					{
						if ((Object)(object)s.ModelChangeCharacter == (Object)null)
						{
							return "-";
						}
						List<SkillInfo> skills = s.ModelChangeCharacter.Skills;
						string text25 = "";
						if (skills != null)
						{
							int num = ((skills.Count > 14) ? 14 : skills.Count);
							for (int i = 0; i < num; i++)
							{
								if (!((Object)(object)skills[i] == (Object)null))
								{
									text25 = text25 + ((text25.Length > 0) ? "; " : "") + ((Object)skills[i]).name;
								}
							}
							if (skills.Count > num)
							{
								text25 = text25 + "; (+" + (skills.Count - num) + ")";
							}
						}
						return ((Object)s.ModelChangeCharacter).name + " [" + text25 + "]";
					});
					string text8 = Campo("aura", () => (!s.IsAura) ? "nao" : "sim");
					string text9 = Campo("raio", () => s.AuraRadius.ToString());
					string text10 = Campo("auraAli", () => (!s.AuraEffectsAllies) ? "nao" : "sim");
					string text11 = Campo("auraIni", () => (!s.AuraEffectsEnemies) ? "nao" : "sim");
					string text12 = Campo("beneficio", () => (!s.IsBeneficial) ? ((!s.IsHarmful) ? "Neutro" : "Debuff") : "Buff");
					string text13 = Campo("dur", () => s.Duration);
					string text14 = Campo("maxStk", () => s.MaxStacks.ToString());
					string text15 = Campo("nEfeitosTot", () => EfeitosInfo.Conta(s.Effects).ToString());
					string text16 = Campo("nAttrEf", () => EfeitosInfo.Conta(s.AttributeEffects).ToString());
					string text17 = Campo("nTrig", () => EfeitosInfo.Conta(s.SkillTriggers).ToString());
					string text18 = Campo("trigEf", () => TriggersDe(s));
					string text19 = Campo("expr", () => EfeitosInfo.Junta(s.DescriptionExpressions));
					string text20 = Campo("danoExpr", () => EfeitosInfo.Junta(s.DamageExpressionOverrides));
					string text21 = Campo("refAcao", () => EfeitosInfo.Nome((Object)(object)s.TooltipDamageInfoRefAction));
					string text22 = Campo("refStatus", () => EfeitosInfo.Nome((Object)(object)s.TooltipDamageInfoRefStatus));
					string text23 = Campo("tick", () => TickDe(s));
					string text24 = Campo("auraSts", () => AuraDe(s));
					Plugin.Log.LogInfo((object)("[Status] '" + text + "' | tipo=" + text2 + " | raridade=" + text3 + " | " + $"efeitos={arg} | efeitosDano={arg2} | nEfeitosDano={nGerais} | " + "aura=" + text8 + " | raio=" + text9 + " | auraAli=" + text10 + " | auraIni=" + text11 + " | modelo=" + text7 + " | beneficio=" + text12 + " | dur=" + text13 + " | maxStk=" + text14 + " | nEfeitosTot=" + text15 + " | efTipos=" + text5 + " | nAttrEf=" + text16 + " | attrTipos=" + text6 + " | nTrig=" + text17 + " | trigEf=" + text18 + " | expr=" + text19 + " | danoExpr=" + text20 + " | refAcao=" + text21 + " | refStatus=" + text22 + " | tick=" + text23 + " | auraSts=" + text24 + " | desc=\"" + text4 + "\""));
				}
				Plugin.Log.LogInfo((object)("[Efeitos] resumo (status): " + EfeitosInfo.Resumo()));
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("[Status] o laço do inventário ABORTOU fora de campo (" + ex.GetType().Name + ": " + ex.Message + ") - o dump pode estar incompleto (campo problematico sai como '!erro:Tipo'; falha assim nao e campo)."));
			}
		}
	}
	[HarmonyPatch(typeof(WorldMapGenerator), "GetRandomEvent")]
	public static class EventRollDebugPatch
	{
		private static void Postfix(NodeTypeEventSet nodeTypeEventSet, TerrainAndTime terrainAndTime, int level, PartyEvent __result)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)__result == (Object)null)
				{
					Plugin.Log.LogWarning((object)"[Event] roll retornou null (ver fallbacks no Player.log).");
				}
				else
				{
					Plugin.Log.LogInfo((object)($"[Event] '{((Object)__result).name}' | nodo={nodeTypeEventSet.nodeType} " + $"minor={nodeTypeEventSet.isMinor} spawn={nodeTypeEventSet.eventSpawnType} | " + $"terreno={terrainAndTime.TerrainType}/{terrainAndTime.TimeOfDay} | nível={level} | " + $"chance={__result.ChanceRatio} | temBatalha={__result.HasBattle}"));
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[Event] erro no debug: " + ex.Message));
			}
		}
	}
	[HarmonyPatch(typeof(GameLogic), "GetTotalExpValue")]
	public static class ExpDebugPatch
	{
		private static void Postfix(float modifier, ref float __result)
		{
			try
			{
				float num = ((modifier != 0f) ? (__result / modifier) : 0f);
				float experienceMod = GameLogic.instance.CurrentDifficulty.ExperienceMod;
				Plugin.Log.LogInfo((object)($"[Exp] total={__result:F1} | base(por inimigos)={num:F1} | " + $"modificador da batalha={modifier:F2} | multiplicador de dificuldade={experienceMod:F2}"));
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[Exp] erro no debug: " + ex.Message));
			}
		}
	}
	[HarmonyPatch(typeof(Character), "GetExpValue")]
	public static class EnemyExpDebugPatch
	{
		private static void Postfix(Character __instance, ref float __result)
		{
			try
			{
				if (__instance != null)
				{
					Plugin.Log.LogInfo((object)($"[ExpInimigo] {((Object)__instance.CharacterInfo).name} (Lv {__instance.Level}, " + $"PointValue {__instance.PointValue}) = {__result:F1} exp"));
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[ExpInimigo] erro no debug: " + ex.Message));
			}
		}
	}
	internal static class FlameProbe
	{
		internal const string Tag = "[FlameRV49]";

		internal const string Atributo = "ShrineEffectBonus";

		internal const string StatusFlame = "Flame Shrine Aura";

		internal const string StatusDecay = "Decay Shrine Aura";

		private static bool _bootFeito;

		private static int _bootEstavel;

		private static int _bootUltimo = -1;

		private static int _bootTentativas;

		private static bool _emMatriz;

		private static readonly HashSet<string> _textosRegistrados = new HashSet<string>();

		private static readonly string[] ChavesDeDano = new string[9] { "FireDamage", "ShadowDamage", "ColdDamage", "LightningDamage", "PhysicalDamage", "HolyDamage", "Healing", "HealingForced", "ManaDamage" };

		internal static bool EmMatriz => _emMatriz;

		internal static bool Interessa(string expressao)
		{
			if (!string.IsNullOrEmpty(expressao))
			{
				return expressao.IndexOf("ShrineEffectBonus", StringComparison.Ordinal) >= 0;
			}
			return false;
		}

		internal static void Marca(string linha)
		{
			try
			{
				Plugin.Log.LogInfo((object)("[FlameRV49] " + linha));
			}
			catch (Exception)
			{
			}
		}

		internal static void Aviso(string linha)
		{
			try
			{
				Plugin.Log.LogWarning((object)("[FlameRV49] " + linha));
			}
			catch (Exception)
			{
			}
		}

		internal static string Limpa(string s)
		{
			return EfeitosInfo.Limpa(s);
		}

		private static string Seguro(string rotulo, Func<string> leitura)
		{
			try
			{
				return leitura() ?? "(vazio)";
			}
			catch (Exception ex)
			{
				return "!erro:" + ex.GetType().Name;
			}
		}

		internal static string NomeDe(Character c)
		{
			return Seguro("nome", delegate
			{
				string characterName = c.CharacterName;
				return (!string.IsNullOrEmpty(characterName)) ? characterName : "(sem nome)";
			});
		}

		internal static string TipoDe(Character c)
		{
			return Seguro("tipo", () => (!c.IsAI) ? "player" : ((object)c.EnemyType/*cast due to .constrained prefix*/).ToString());
		}

		internal static string BonusDe(Character c)
		{
			return Seguro("bonus", delegate
			{
				if (c == null)
				{
					return "(sem personagem)";
				}
				return ((Object)(object)Game.Instance == (Object)null || (Object)(object)Game.Instance.GetAttribute("ShrineEffectBonus") == (Object)null) ? "(atributo ausente neste build)" : c["ShrineEffectBonus"].ToString("0.###");
			});
		}

		internal static string Descreve(Character c)
		{
			if (c == null)
			{
				return "(null)";
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("'").Append(NomeDe(c)).Append("'");
			stringBuilder.Append(" IsAI=").Append(Seguro("isai", () => (!c.IsAI) ? "nao" : "sim"));
			stringBuilder.Append(" tipo=").Append(TipoDe(c));
			stringBuilder.Append(" time=").Append(Seguro("time", () => c.TeamIndex.ToString()));
			stringBuilder.Append(" id=").Append(Seguro("id", () => c.ID.ToString()));
			stringBuilder.Append(" MaxHealth=").Append(Seguro("maxhealth", () => c.MaxHealth.ToString("0.#")));
			stringBuilder.Append(" ShrineEffectBonus=").Append(BonusDe(c));
			stringBuilder.Append(" info=").Append(Seguro("info", () => (!((Object)(object)c.CharacterInfo == (Object)null)) ? ((Object)c.CharacterInfo).name : "(sem CharacterInfo)"));
			return stringBuilder.ToString();
		}

		private static void AnexaCrus(StringBuilder sb, string rotulo, SimpleDefaultDictionary<string, float> dic)
		{
			if (dic == null)
			{
				return;
			}
			string[] chavesDeDano = ChavesDeDano;
			foreach (string text in chavesDeDano)
			{
				try
				{
					if (dic.ContainsKey(text))
					{
						sb.Append(" ").Append(rotulo).Append("[")
							.Append(text)
							.Append("]=")
							.Append(dic[text].ToString("0.####"));
					}
				}
				catch (Exception ex)
				{
					sb.Append(" ").Append(rotulo).Append("[")
						.Append(text)
						.Append("]=!erro:")
						.Append(ex.GetType().Name);
				}
			}
		}

		internal static string Crus(GameFunctionParameters p)
		{
			StringBuilder stringBuilder = new StringBuilder();
			AnexaCrus(stringBuilder, "TargetStored", ((GameFunctionParameters)(ref p)).TargetStored);
			AnexaCrus(stringBuilder, "SourceStored", ((GameFunctionParameters)(ref p)).SourceStored);
			if (stringBuilder.Length != 0)
			{
				return stringBuilder.ToString().Trim();
			}
			return "(nenhuma chave de dano gravada)";
		}

		private static bool FormaSegura(string expressao, out bool gravaNoTarget, out string chave)
		{
			gravaNoTarget = true;
			chave = null;
			if (string.IsNullOrEmpty(expressao))
			{
				return false;
			}
			int length;
			if (expressao.StartsWith("TargetStored[\"", StringComparison.Ordinal))
			{
				length = "TargetStored[\"".Length;
			}
			else
			{
				if (!expressao.StartsWith("SourceStored[\"", StringComparison.Ordinal))
				{
					return false;
				}
				gravaNoTarget = false;
				length = "SourceStored[\"".Length;
			}
			int num = expressao.IndexOf("\"] = ", length, StringComparison.Ordinal);
			if (num < 0)
			{
				return false;
			}
			if (Conta(expressao, "\"] = ") != 1)
			{
				return false;
			}
			chave = expressao.Substring(length, num - length);
			return !string.IsNullOrEmpty(chave);
		}

		private static int Conta(string texto, string trecho)
		{
			int num = 0;
			for (int num2 = texto.IndexOf(trecho, StringComparison.Ordinal); num2 >= 0; num2 = texto.IndexOf(trecho, num2 + trecho.Length, StringComparison.Ordinal))
			{
				num++;
			}
			return num;
		}

		private static void RegistrarTexto(string expressao)
		{
			if (!_textosRegistrados.Add(expressao))
			{
				return;
			}
			try
			{
				if (((typeof(Game).Assembly.GetType("CompiledDynamicExpresso") ?? typeof(Game).Assembly.GetType("Burst2Flame.CompiledDynamicExpresso"))?.GetField("MissingExpressions", BindingFlags.Static | BindingFlags.NonPublic))?.GetValue(null) is HashSet<string> hashSet)
				{
					hashSet.Add(expressao);
				}
			}
			catch (Exception)
			{
			}
		}

		internal static void Matriz(string expressao, GameFunctionParameters parameters)
		{
			//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			if (_emMatriz)
			{
				return;
			}
			try
			{
				if (!FormaSegura(expressao, out var gravaNoTarget, out var chave))
				{
					Marca("MATRIZ pulada: a expressao nao tem a forma segura 'Stored[\"X\"] = <RHS>' (uma atribuicao, no inicio) - nada foi reavaliado.");
					return;
				}
				Character alvo = ((GameFunctionParameters)(ref parameters)).Target;
				if (alvo == null)
				{
					Marca("MATRIZ pulada: o proc nao trouxe `Target` (sem personagem para a contra-prova).");
					return;
				}
				Marca("MATRIZ inicio: Source = o ALVO do proc (" + NomeDe(alvo) + ", ShrineEffectBonus real=" + BonusDe(alvo) + "), chave='" + chave + "', gravada em " + (gravaNoTarget ? "TargetStored" : "SourceStored"));
				string text = "Source[\"ShrineEffectBonus\"]";
				if (expressao.IndexOf(text, StringComparison.Ordinal) < 0)
				{
					Marca("MATRIZ: a expressao nao cita " + text + " - contra-prova nao se aplica.");
					return;
				}
				List<KeyValuePair<string, float?>> list = new List<KeyValuePair<string, float?>>();
				list.Add(new KeyValuePair<string, float?>("bonus do proprio alvo (substituicao NENHUMA)", null));
				list.Add(new KeyValuePair<string, float?>("bonus=0 (sem Omnism)", 0f));
				list.Add(new KeyValuePair<string, float?>("bonus=8 (Omnism I)", 8f));
				list.Add(new KeyValuePair<string, float?>("bonus=20 (Omnism II)", 20f));
				list.Add(new KeyValuePair<string, float?>("bonus=100 (Horn of Devotion)", 100f));
				List<string> list2 = new List<string>();
				_emMatriz = true;
				GameFunctionParameters currentGameFunctionParameters = Game.CurrentGameFunctionParameters;
				try
				{
					foreach (KeyValuePair<string, float?> item in list)
					{
						string text2 = expressao;
						if (item.Value.HasValue)
						{
							text2 = expressao.Replace(text, "(" + item.Value.Value.ToString("0.###") + ")");
							RegistrarTexto(text2);
						}
						GameFunctionParameters val = parameters;
						((GameFunctionParameters)(ref val)).Source = alvo;
						((GameFunctionParameters)(ref val)).SourceStored = new SimpleDefaultDictionary<string, float>(new Dictionary<string, float>());
						((GameFunctionParameters)(ref val)).TargetStored = new SimpleDefaultDictionary<string, float>(new Dictionary<string, float>());
						Game.EvalVoid(text2, val);
						SimpleDefaultDictionary<string, float> val2 = (gravaNoTarget ? ((GameFunctionParameters)(ref val)).TargetStored : ((GameFunctionParameters)(ref val)).SourceStored);
						string text3;
						try
						{
							text3 = ((val2 != null && val2.ContainsKey(chave)) ? val2[chave].ToString("0.####") : "!ausente");
						}
						catch (Exception ex)
						{
							text3 = "!erro:" + ex.GetType().Name;
						}
						list2.Add("MATRIZ '" + item.Key + "' -> " + chave + "=" + text3);
					}
				}
				finally
				{
					Game.CurrentGameFunctionParameters = currentGameFunctionParameters;
					_emMatriz = false;
				}
				foreach (string item2 in list2)
				{
					Marca(item2);
				}
				Marca("MATRIZ fim (Source = " + NomeDe(alvo) + "; MaxHealth do alvo depois de tudo=" + Seguro("maxhealth", () => alvo.MaxHealth.ToString("0.#")) + ")");
			}
			catch (Exception ex2)
			{
				_emMatriz = false;
				Aviso("MATRIZ falhou (" + ex2.GetType().Name + "): " + ex2.Message);
			}
		}

		private static void Dump(ActionStatusInfo s)
		{
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Expected I4, but got Unknown
			if ((Object)(object)s == (Object)null)
			{
				return;
			}
			Marca("BOOT status '" + Limpa(s.Name) + "' guid=" + Seguro("guid", () => s.Guid.ToString()));
			Marca("BOOT desc='" + Limpa(s.Description ?? "") + "'");
			if (s.DescriptionExpressions != null)
			{
				for (int num = 0; num < s.DescriptionExpressions.Length; num++)
				{
					Marca("BOOT descExpr[" + num + "]='" + Limpa(s.DescriptionExpressions[num] ?? "") + "'");
				}
			}
			Marca("BOOT efeitos_do_status=" + EfeitosInfo.Descreve(s.Effects));
			SkillTrigger[] skillTriggers = s.SkillTriggers;
			if (skillTriggers == null || skillTriggers.Length == 0)
			{
				Marca("BOOT gatilhos=NENHUM no status (a acao do proc nao sai por aqui)");
				return;
			}
			for (int num2 = 0; num2 < skillTriggers.Length; num2++)
			{
				SkillTrigger tg = skillTriggers[num2];
				if (tg == null)
				{
					continue;
				}
				Marca("BOOT gatilho[" + num2 + "] triggerType=" + (int)tg.TriggerType + " (" + ((object)Unsafe.As<TriggerType, TriggerType>(ref tg.TriggerType)/*cast due to .constrained prefix*/).ToString() + ") condition='" + Limpa(tg.Condition ?? "") + "' alvos='" + Limpa(tg.Targets ?? "") + "' useTriggerSource=" + Seguro("uts", () => (!tg.UseTriggerSource) ? "nao" : "SIM") + " triggerSource=" + ((tg.TriggerSource == null) ? "(null)" : Descreve(tg.TriggerSource)) + " cd=" + Seguro("cd", () => tg.Cooldown.ToString("0.#")) + " maxUses='" + Limpa(tg.MaxNumUses ?? "") + "'");
				string text = num2.ToString();
				IEffectInfo[] generalEffects = (IEffectInfo[])(object)tg.GeneralEffects;
				Marca("BOOT gatilho[" + text + "] generalEffects=" + EfeitosInfo.Descreve(generalEffects));
				if (tg.Actions == null)
				{
					continue;
				}
				for (int num3 = 0; num3 < tg.Actions.Length; num3++)
				{
					ActionInfo val = tg.Actions[num3];
					if ((Object)(object)val == (Object)null)
					{
						continue;
					}
					Marca("BOOT acao[" + num3 + "] '" + Limpa(((Object)val).name) + "' useCondition='" + Limpa(val.UseCondition ?? "") + "'");
					Marca("BOOT acao[" + num3 + "] efeitos=" + EfeitosInfo.Descreve(val.Effects));
					if (val.DescriptionExpressions != null)
					{
						for (int num4 = 0; num4 < val.DescriptionExpressions.Length; num4++)
						{
							Marca("BOOT acao[" + num3 + "] descExpr[" + num4 + "]='" + Limpa(val.DescriptionExpressions[num4] ?? "") + "'");
						}
					}
				}
			}
		}

		private static void DumpGroundEffectsDeShrine()
		{
			try
			{
				if ((Object)(object)Game.Instance == (Object)null || Game.Instance.GroundEffects == null)
				{
					Marca("BOOT ground effects: lista indisponivel");
					return;
				}
				List<GroundEffectInfo> groundEffects = Game.Instance.GroundEffects;
				Marca("BOOT ground effects carregados=" + groundEffects.Count);
				StringBuilder stringBuilder = new StringBuilder();
				foreach (GroundEffectInfo ge in new List<GroundEffectInfo>(groundEffects))
				{
					if ((Object)(object)ge == (Object)null)
					{
						continue;
					}
					string text = Seguro("nome_asset", () => ((Object)ge).name);
					string text2 = Seguro("tipo_ge", () => ((object)Unsafe.As<GroundEffectType, GroundEffectType>(ref ge.GroundEffectType)/*cast due to .constrained prefix*/).ToString());
					if (text2 != "Shrine")
					{
						stringBuilder.Append(text).Append("(").Append(text2)
							.Append(") ");
						continue;
					}
					string text3 = Seguro("nome_campo", () => ge.Name ?? "(sem Name)");
					Marca("BOOT GE '" + text + "' campo='" + text3 + "' tipo=" + text2);
					Marca("BOOT GE '" + text + "' raio=" + Seguro("raio", () => ge.Radius.ToString()) + " alvos_enemy=" + Seguro("ae", () => (!ge.GroundTargets.EffectsEnemies) ? "nao" : "SIM") + " alvos_player=" + Seguro("ap", () => (!ge.GroundTargets.EffectsPlayers) ? "nao" : "SIM") + " ignora_summons=" + Seguro("is", () => (!ge.GroundTargets.IgnorePlayerSummons) ? "nao" : "SIM") + " targetingComplexo=" + Seguro("tc", () => (!ge.UseComplexTargeting) ? "nao" : "SIM") + " targetConditions='" + Seguro("tcond", () => ge.GroundTargetConditions ?? "") + "'");
					Marca("BOOT GE '" + text + "' expira=" + Seguro("exp", () => (!ge.CanExpire) ? "nao" : "SIM") + " turnos=" + Seguro("turnos", () => ge.TurnsToExpire.ToString()) + " charInfo=" + Seguro("ci", () => (!((Object)(object)ge.CharacterInfo == (Object)null)) ? ((Object)ge.CharacterInfo).name : "(sem CharacterInfo)") + " nStatuses=" + Seguro("ns", () => (ge.ActionStatuses != null) ? ge.ActionStatuses.Length.ToString() : "0") + " nTriggers=" + Seguro("nt", () => (ge.SkillTriggers != null) ? ge.SkillTriggers.Length.ToString() : "0"));
					if (ge.ActionStatuses != null)
					{
						StringBuilder stringBuilder2 = new StringBuilder();
						ActionStatusInfo[] actionStatuses = ge.ActionStatuses;
						foreach (ActionStatusInfo val in actionStatuses)
						{
							if (!((Object)(object)val == (Object)null))
							{
								stringBuilder2.Append(Limpa(val.Name)).Append("; ");
							}
						}
						Marca("BOOT GE '" + text + "' statuses=" + stringBuilder2.ToString().TrimEnd(' ', ';'));
					}
					try
					{
						if (!((Object)(object)ge.CharacterInfo != (Object)null) || ge.CharacterInfo.CharacterEffects == null)
						{
							continue;
						}
						StringBuilder stringBuilder3 = new StringBuilder();
						CharacterEffectInfo[] characterEffects = ge.CharacterInfo.CharacterEffects;
						foreach (CharacterEffectInfo val2 in characterEffects)
						{
							if (val2 != null)
							{
								stringBuilder3.Append(Limpa(((Object)(object)val2.CharacterAttribute == (Object)null) ? "(sem atributo)" : ((Object)val2.CharacterAttribute).name)).Append("=").Append(Limpa(val2.Amount ?? ""))
									.Append("; ");
							}
						}
						Marca("BOOT GE '" + text + "' charInfo.CharacterEffects=" + ((stringBuilder3.Length == 0) ? "(vazio)" : stringBuilder3.ToString().TrimEnd(' ', ';')));
					}
					catch (Exception ex)
					{
						Marca("BOOT GE '" + text + "' CharacterEffects=!erro:" + ex.GetType().Name);
					}
				}
				if (stringBuilder.Length > 0)
				{
					Marca("BOOT ground effects NAO-shrine: " + stringBuilder.ToString().TrimEnd());
				}
			}
			catch (Exception ex2)
			{
				Aviso("BOOT ground effects falhou (" + ex2.GetType().Name + "): " + ex2.Message);
			}
		}

		internal static void TentarBoot(List<ActionStatusInfo> lista)
		{
			if (_bootFeito || lista == null)
			{
				return;
			}
			try
			{
				if (lista.Count == _bootUltimo)
				{
					_bootEstavel++;
				}
				else
				{
					_bootEstavel = 1;
					_bootUltimo = lista.Count;
				}
				_bootTentativas++;
				if (_bootEstavel < 5 || lista.Count < 2)
				{
					return;
				}
				_bootFeito = true;
				Marca("BOOT status carregados=" + lista.Count + " atributo 'ShrineEffectBonus' no build=" + Seguro("attr", () => (!((Object)(object)Game.Instance != (Object)null) || !((Object)(object)Game.Instance.GetAttribute("ShrineEffectBonus") != (Object)null)) ? "NAO" : "SIM"));
				List<ActionStatusInfo> list = new List<ActionStatusInfo>(lista);
				ActionStatusInfo val = null;
				ActionStatusInfo val2 = null;
				foreach (ActionStatusInfo item in list)
				{
					if (!((Object)(object)item == (Object)null))
					{
						if ((Object)(object)val == (Object)null && item.Name == "Flame Shrine Aura")
						{
							val = item;
						}
						if ((Object)(object)val2 == (Object)null && item.Name == "Decay Shrine Aura")
						{
							val2 = item;
						}
					}
				}
				if ((Object)(object)val == (Object)null)
				{
					Aviso("BOOT status 'Flame Shrine Aura' NAO esta na lista de " + lista.Count + " status deste build - sem dump do gatilho (a medicao do proc continua valendo)");
				}
				Dump(val);
				Dump(val2);
				DumpGroundEffectsDeShrine();
				Marca("BOOT os alvos da acao citam 'Target.GetValueByEnemyType' e o fator lê 'Source[ShrineEffectBonus]' - quem ocupa o Source do PROC REAL sai nas linhas PROC abaixo");
			}
			catch (Exception ex)
			{
				_bootFeito = true;
				Aviso("BOOT dump falhou (" + ex.GetType().Name + "): " + ex.Message);
			}
		}
	}
	[HarmonyPatch(typeof(Game), "get_ActionStatuses")]
	public static class FlameBootPatch
	{
		private static void Postfix(List<ActionStatusInfo> __result)
		{
			FlameProbe.TentarBoot(__result);
		}
	}
	[HarmonyPatch(typeof(Game), "EvalVoid")]
	public static class FlameEvalVoidPatch
	{
		private static void Prefix(string expression, GameFunctionParameters parameters, out bool __state)
		{
			__state = !FlameProbe.EmMatriz && FlameProbe.Interessa(expression);
			if (__state)
			{
				FlameProbe.Marca("PROC expr='" + FlameProbe.Limpa(expression) + "'");
				FlameProbe.Marca("PROC Source=" + FlameProbe.Descreve(((GameFunctionParameters)(ref parameters)).Source));
				FlameProbe.Marca("PROC Target=" + FlameProbe.Descreve(((GameFunctionParameters)(ref parameters)).Target));
			}
		}

		private static void Postfix(string expression, GameFunctionParameters parameters, bool __state)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if (__state)
			{
				FlameProbe.Marca("CRU " + FlameProbe.Crus(parameters));
				FlameProbe.Matriz(expression, parameters);
			}
		}
	}
	[HarmonyPatch(typeof(Character), "GetActionDamage")]
	public static class FlameGetActionDamagePatch
	{
		private static void Prefix(string actionString, out bool __state)
		{
			__state = !FlameProbe.EmMatriz && FlameProbe.Interessa(actionString);
		}

		private unsafe static void Postfix(bool __state, List<DamageInstance> __result, Character source, Character target)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			if (!__state)
			{
				return;
			}
			if (__result == null || __result.Count == 0)
			{
				FlameProbe.Marca("DANO final: NENHUMA instance (expressao sem dano) - fonte=" + FlameProbe.NomeDe(source) + " alvo=" + FlameProbe.NomeDe(target));
				return;
			}
			for (int i = 0; i < __result.Count; i++)
			{
				DamageInstance val = __result[i];
				FlameProbe.Marca("DANO final[" + i + "] tipo=" + ((object)(*(DamageType*)(&val.DamageType))/*cast due to .constrained prefix*/).ToString() + " min=" + val.DamageMin.ToString("0.####") + " max=" + val.DamageMax.ToString("0.####") + " ACTUAL=" + val.DamageActual.ToString("0.####") + " crit=" + val.DidCrit + " quem_leva=" + FlameProbe.Descreve(val.DamageTarget));
			}
		}
	}
	[HarmonyPatch(typeof(Character), "GetValueByEnemyType")]
	public static class FlamePctPatch
	{
		private static void Postfix(Character __instance, float boss, float champion, float elite, float soldier, float fodder, float player, float __result)
		{
			if (!FlameProbe.EmMatriz)
			{
				FlameProbe.Marca("PCT de " + FlameProbe.Descreve(__instance) + " -> " + __result.ToString("0.####") + " (boss=" + boss.ToString("0.####") + " champion=" + champion.ToString("0.####") + " elite=" + elite.ToString("0.####") + " soldier=" + soldier.ToString("0.####") + " fodder=" + fodder.ToString("0.####") + " player=" + player.ToString("0.####") + ")");
			}
		}
	}
	[HarmonyPatch(typeof(GameLogic), "ApplyGoldModifiers")]
	public static class GoldModifierDebugPatch
	{
		private static void Postfix(float originalGold, ref float __result)
		{
			try
			{
				NetworkingManager instance = NetworkingManager.Instance;
				List<Character> list = ((instance != null) ? instance.MyPartyCharacters : null);
				List<string> list2 = new List<string>();
				float num = 0f;
				if (list != null)
				{
					foreach (Character item in list)
					{
						float num2 = item["GoldMod"];
						num += num2;
						list2.Add($"{item.CharacterName}={num2}");
					}
				}
				Plugin.Log.LogInfo((object)(string.Format("[Gold] ouro base={0} party=[{1}] ", originalGold, (list2.Count > 0) ? string.Join(", ", list2) : "-") + $"GoldMod soma={num} ouro final={__result}"));
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[Gold] erro no debug: " + ex.Message));
			}
		}
	}
	[HarmonyPatch(typeof(Game), "get_Items")]
	public static class ItemInventoryPatch
	{
		private static bool _itemsDumped;

		private static int _itemsLast = -1;

		private static int _itemsStable;

		private static bool _modsDumped;

		private static void Postfix(List<ItemInfo> __result)
		{
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (_itemsDumped || __result == null || __result.Count <= 1)
				{
					return;
				}
				if (__result.Count == _itemsLast)
				{
					_itemsStable++;
				}
				else
				{
					_itemsStable = 1;
					_itemsLast = __result.Count;
				}
				if (_itemsStable < 5)
				{
					return;
				}
				_itemsDumped = true;
				EfeitosInfo.Zerar();
				Plugin.Log.LogInfo((object)$"[Item] Inventário: {__result.Count} itens base carregados.");
				foreach (ItemInfo item in __result)
				{
					if ((Object)(object)item == (Object)null)
					{
						continue;
					}
					string text = item.OptionalDescription ?? "";
					StringBuilder stringBuilder = new StringBuilder();
					if (item.IsConsumable && (Object)(object)item.ConsumableAction != (Object)null)
					{
						stringBuilder.Append(((Object)item.ConsumableAction).name).Append("::");
						if (item.ConsumableAction.Effects != null)
						{
							IEffectInfo[] effects = item.ConsumableAction.Effects;
							foreach (IEffectInfo obj in effects)
							{
								GeneralEffect val = (GeneralEffect)(object)((obj is GeneralEffect) ? obj : null);
								if (val != null && !string.IsNullOrEmpty(val.Action))
								{
									stringBuilder.Append(val.Action).Append("; ");
								}
							}
						}
					}
					Plugin.Log.LogInfo((object)($"[Item] '{((Object)item).name}' | tipo={item.ItemType} | raridade={item.Rarity} | " + string.Format("lvlMin={0} | consumivel={1} | ", item.MinLevel, stringBuilder.ToString().Replace("|", "/").Replace("\n", " ")) + "consEf=" + EfeitosInfo.Descreve((item.IsConsumable && (Object)(object)item.ConsumableAction != (Object)null) ? item.ConsumableAction.Effects : null) + " | desc=\"" + text.Replace("\n", " ") + "\""));
				}
				Plugin.Log.LogInfo((object)("[Efeitos] resumo (itens): " + EfeitosInfo.Resumo()));
				DumpItemMods();
				PowerupInventoryPatch.Trigger();
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[Item] erro no inventário: " + ex.Message));
			}
		}

		private static void DumpItemMods()
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (_modsDumped)
				{
					return;
				}
				ItemMod[] itemMods = Game.Instance.ItemMods;
				if (itemMods == null || itemMods.Length <= 1)
				{
					return;
				}
				_modsDumped = true;
				Plugin.Log.LogInfo((object)$"[ItemMod] Inventário: {itemMods.Length} afixos carregados.");
				ItemMod[] array = itemMods;
				foreach (ItemMod val in array)
				{
					if (!((Object)(object)val == (Object)null))
					{
						string text = val.Description ?? "";
						Plugin.Log.LogInfo((object)($"[ItemMod] '{((Object)val).name}' | tipo={val.ItemModType} | raridade={val.Rarity} | " + "desc=\"" + text.Replace("\n", " ") + "\""));
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[ItemMod] erro no inventário: " + ex.Message));
			}
		}
	}
	[HarmonyPatch(typeof(MessageWindowManager), "CreateBattleLogMessage")]
	public static class LifeStealDebugPatch
	{
		private static void Postfix(Character source, Character target, string message, float value)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (message == null)
				{
					return;
				}
				if (message == "[source] healed [value] health from life steal" && source != null)
				{
					List<string> list = new List<string>();
					foreach (SkillType value2 in Enum.GetValues(typeof(SkillType)))
					{
						float num = source["LifeSteal" + ((object)value2/*cast due to .constrained prefix*/).ToString()];
						if (num > 0f)
						{
							list.Add($"{(object)value2}={num:F1}");
						}
					}
					float num2 = source["LifeSteal"];
					float maxHealth = source.MaxHealth;
					_ = maxHealth * num2 / 100f;
					Plugin.Log.LogInfo((object)($"[LifeSteal] {source.CharacterName} curou {value:F1} | " + $"vidaMáxima={maxHealth:F1} | LifeSteal%={num2:F1} | nível={source.Level} | " + "porTipo=[" + string.Join(", ", list) + "] | " + $"(15% da vidaMáx seria {maxHealth * 0.15f:F1})"));
				}
				else if (message == "[source] dealt [value] Damage to [target]" && source != null && !source.IsAI && value > 0f)
				{
					Plugin.Log.LogInfo((object)($"[Dmg] {source.CharacterName} causou {value:F1} dano em " + string.Format("{0} | LifeSteal%={1:F1}", (target != null) ? target.CharacterName : "?", source["LifeSteal"])));
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[LifeSteal] erro no debug: " + ex.Message));
			}
		}
	}
	[HarmonyPatch(typeof(GameLogic), "GetCharacterLootDropModifier")]
	public static class LootModifierDebugPatch
	{
		private static void Postfix(ref float __result)
		{
			try
			{
				NetworkingManager instance = NetworkingManager.Instance;
				List<Character> list = ((instance != null) ? instance.MyPartyCharacters : null);
				if (list == null)
				{
					Plugin.Log.LogInfo((object)"[Loot] Modificador de loot: party nula.");
					return;
				}
				Root root = ((Observer<Root>)(object)NetworkingManager.Instance.NetworkManager).Root;
				Plugin.Log.LogInfo((object)$"[Loot] PlayingRoguelike={((root != null) ? new bool?(root.PlayingRoguelike) : ((bool?)null))}");
				ObservableRoguelikePowerupAndLevelSet val = default(ObservableRoguelikePowerupAndLevelSet);
				foreach (Character item in list)
				{
					float num = item["DropQuantityMod"];
					List<string> list2 = new List<string>();
					if (root != null && root.RoguelikePowerupsByConnection != null && root.RoguelikePowerupsByConnection.TryGetValue(item.OwnerID, ref val) && val.PowerupAndLevels != null)
					{
						foreach (ObservableRoguelikePowerupAndLevel powerupAndLevel in val.PowerupAndLevels)
						{
							if (powerupAndLevel.Level > 0)
							{
								list2.Add(string.Format("{0} Lv{1}", Game.Instance.GetFromRoguelikePowerupDict(Game.Instance.GetGuidFromString(powerupAndLevel.Guid))?.Name ?? "?", powerupAndLevel.Level));
							}
						}
					}
					Plugin.Log.LogInfo((object)($"[Loot] {item.CharacterName}: DropQuantityMod={num}; " + string.Format("GoldMod={0}; DamageMod={1}; ", item["GoldMod"], item["DamageMod"]) + string.Format("DamageModHealing={0}; DamageReduction={1}; ", item["DamageModHealing"], item["DamageReduction"]) + string.Format("FreeMove={0}; RangeMelee={1}; ", item["FreeMovementPoints"], item["RangeTypeAdderMelee"]) + string.Format("RangeRanged={0}; SkillOpts={1}; ", item["RangeTypeAdderRanged"], item["AdditionalRoguelikeSkillOptions"]) + string.Format("AttrPtsPerLvl={0}; ", item["AdditionalRoguelikeAttributesPointsPerLevel"]) + string.Format("Resilience={0}; TakeCover={1}; ", item["Resilience"], item["TakeCover"]) + "powerups ativos: " + ((list2.Count > 0) ? string.Join(", ", list2) : "nenhum")));
				}
				Plugin.Log.LogInfo((object)$"[Loot] Multiplicador final={__result}");
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[Loot] erro no debug: " + ex.Message + "\n" + ex.StackTrace));
			}
		}
	}
	[HarmonyPatch(typeof(Game), "get_RoguelikePowerups")]
	public static class PowerupInventoryPatch
	{
		private static bool _dumped;

		internal static void Trigger()
		{
			try
			{
				Plugin.Log.LogInfo((object)"[Powerup] trigger chamado (forçando o load lazy).");
				RoguelikePowerup[] roguelikePowerups = Game.Instance.RoguelikePowerups;
				Plugin.Log.LogInfo((object)("[Powerup] getter retornou " + ((roguelikePowerups == null) ? "null" : (roguelikePowerups.Length + " itens")) + "."));
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[Powerup] trigger falhou: " + ex.Message));
			}
		}

		private static void Postfix(RoguelikePowerup[] __result)
		{
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (_dumped || __result == null || __result.Length <= 1)
				{
					return;
				}
				_dumped = true;
				Plugin.Log.LogInfo((object)$"[Powerup] Inventário: {__result.Length} powerups carregados.");
				foreach (RoguelikePowerup val in __result)
				{
					if ((Object)(object)val == (Object)null)
					{
						continue;
					}
					if (val.PowerupLevels == null || val.PowerupLevels.Length == 0)
					{
						Plugin.Log.LogInfo((object)$"[Powerup] '{val.Name}' | guid={val.Guid} | (sem níveis)");
						continue;
					}
					for (int j = 0; j < val.PowerupLevels.Length; j++)
					{
						RoguelikePowerupLevel val2 = val.PowerupLevels[j];
						if (val2 == null)
						{
							continue;
						}
						StringBuilder stringBuilder = new StringBuilder();
						if (val2.CharacterEffects != null)
						{
							CharacterEffectInfo[] characterEffects = val2.CharacterEffects;
							foreach (CharacterEffectInfo val3 in characterEffects)
							{
								if (val3 != null && !((Object)(object)val3.CharacterAttribute == (Object)null))
								{
									stringBuilder.Append(((Object)val3.CharacterAttribute).name).Append(':').Append(val3.CharacterEffectMethod)
										.Append(':')
										.Append(val3.Amount)
										.Append(", ");
								}
							}
						}
						string arg = (val2.Description ?? "").Replace("\n", " ");
						Plugin.Log.LogInfo((object)($"[Powerup] '{val.Name}' | guid={val.Guid} | nivel={j + 1} | custo={val2.Cost} | " + $"efeitos={stringBuilder} | desc=\"{arg}\""));
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[Powerup] erro no inventário: " + ex.Message));
			}
		}
	}
	[HarmonyPatch(typeof(Game), "get_Skills")]
	public static class SkillInventoryPatch
	{
		private static bool _dumped;

		private static int _lastCount = -1;

		private static int _stableHits;

		private static readonly Dictionary<string, ActionInfo> _acoes = new Dictionary<string, ActionInfo>();

		private static string Limpa(string s)
		{
			return (s ?? "").Replace("\n", " ").Replace("\r", " ").Replace("|", "/")
				.Replace("\"", "'")
				.Trim();
		}

		private static string Junta(string[] itens)
		{
			if (itens == null)
			{
				return "";
			}
			StringBuilder stringBuilder = new StringBuilder();
			foreach (string text in itens)
			{
				if (!string.IsNullOrEmpty(text))
				{
					stringBuilder.Append(Limpa(text)).Append("; ");
				}
			}
			return stringBuilder.ToString().TrimEnd(' ', ';');
		}

		private static void DespejaAcoes()
		{
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0719: Unknown result type (might be due to invalid IL or missing references)
			//IL_0724: Unknown result type (might be due to invalid IL or missing references)
			//IL_073c: Unknown result type (might be due to invalid IL or missing references)
			Plugin.Log.LogInfo((object)$"[Action] Inventário: {_acoes.Count} ações concedidas por skills.");
			EfeitosInfo.Zerar();
			Queue<string> queue = new Queue<string>(_acoes.Keys.OrderBy<string, string>((string x) => x, StringComparer.Ordinal));
			HashSet<string> hashSet = new HashSet<string>();
			while (queue.Count > 0)
			{
				string text = queue.Dequeue();
				if (!hashSet.Add(text) || !_acoes.TryGetValue(text, out var value) || (Object)(object)value == (Object)null)
				{
					continue;
				}
				ActionInfo tooltipDamageInfoRefAction = value.TooltipDamageInfoRefAction;
				ActionStatusInfo tooltipDamageInfoRefStatus = value.TooltipDamageInfoRefStatus;
				if ((Object)(object)tooltipDamageInfoRefAction != (Object)null && !string.IsNullOrEmpty(((Object)tooltipDamageInfoRefAction).name))
				{
					_acoes[((Object)tooltipDamageInfoRefAction).name] = tooltipDamageInfoRefAction;
					queue.Enqueue(((Object)tooltipDamageInfoRefAction).name);
				}
				string text2 = EfeitosDe(value);
				string text3 = (((Object)(object)tooltipDamageInfoRefAction != (Object)null) ? EfeitosDe(tooltipDamageInfoRefAction) : "");
				int num = ContaEfeitos(value);
				int num2 = (((Object)(object)tooltipDamageInfoRefAction != (Object)null) ? ContaEfeitos(tooltipDamageInfoRefAction) : 0);
				string arg = EfeitosInfo.Descreve(value.Effects);
				Plugin.Log.LogInfo((object)($"[Action] '{text}' | dano={value.DamageType} | " + $"nEfeitosTot={EfeitosInfo.Conta(value.Effects)} | efTipos={arg} | " + "efeitos=" + text2 + " | refAcao=" + (((Object)(object)tooltipDamageInfoRefAction != (Object)null) ? Limpa(((Object)tooltipDamageInfoRefAction).name) : "") + " | efeitosRef=" + text3 + " | " + $"nEfeitos={num} | nEfeitosRef={num2} | " + $"nSummons={((value.Summons == null) ? (-1) : value.Summons.Count)} | " + "refStatus=" + (((Object)(object)tooltipDamageInfoRefStatus != (Object)null) ? Limpa(tooltipDamageInfoRefStatus.Name) : "") + " | danoExpr=" + Junta(value.DamageExpressionOverrides) + " | expr=" + Junta(value.DescriptionExpressions) + " | desc=\"" + Limpa(value.Description) + "\""));
				StringBuilder stringBuilder = new StringBuilder();
				int num3 = 0;
				if (value.Targets != null)
				{
					ITargetInfo[] targets = value.Targets;
					foreach (ITargetInfo obj in targets)
					{
						TargetInfo val = (TargetInfo)(object)((obj is TargetInfo) ? obj : null);
						if (val != null)
						{
							num3++;
							stringBuilder.Append('[').Append("sel=").Append(Limpa(val.Selection))
								.Append(';')
								.Append("rsel=")
								.Append(Limpa(val.RangeSelection))
								.Append(';')
								.Append("blast=")
								.Append(Limpa(val.BlastRange))
								.Append(';')
								.Append("range=")
								.Append(val.SimpleRange)
								.Append(';')
								.Append("ali=")
								.Append(val.TargetAllies ? 1 : 0)
								.Append("ini=")
								.Append(val.TargetEnemies ? 1 : 0)
								.Append("self=")
								.Append(val.TargetSelf ? 1 : 0)
								.Append(']');
						}
					}
				}
				StringBuilder stringBuilder2 = new StringBuilder();
				if (value.ActionChances != null)
				{
					foreach (ActionChance actionChance in value.ActionChances)
					{
						if (actionChance != null)
						{
							stringBuilder2.Append(((Object)(object)actionChance.ActionInfo != (Object)null) ? Limpa(((Object)actionChance.ActionInfo).name) : "?").Append(':').Append(actionChance.Chance)
								.Append(',');
						}
					}
				}
				StringBuilder stringBuilder3 = new StringBuilder();
				if (value.StatusEffects != null)
				{
					ActionStatusInfo[] statusEffects = value.StatusEffects;
					foreach (ActionStatusInfo val2 in statusEffects)
					{
						if ((Object)(object)val2 != (Object)null)
						{
							stringBuilder3.Append(Limpa(val2.Name)).Append(',');
						}
					}
				}
				StringBuilder stringBuilder4 = new StringBuilder();
				if (value.SourceStatusEffects != null)
				{
					ActionStatusInfo[] statusEffects = value.SourceStatusEffects;
					foreach (ActionStatusInfo val3 in statusEffects)
					{
						if ((Object)(object)val3 != (Object)null)
						{
							stringBuilder4.Append(Limpa(val3.Name)).Append(',');
						}
					}
				}
				Dictionary<string, int> dictionary = new Dictionary<string, int>();
				if (value.StatusEffects != null)
				{
					ActionStatusInfo[] statusEffects = value.StatusEffects;
					foreach (ActionStatusInfo val4 in statusEffects)
					{
						if (!((Object)(object)val4 == (Object)null))
						{
							string key = Limpa(val4.Name);
							dictionary[key] = ((!dictionary.TryGetValue(key, out var value2)) ? 1 : (value2 + 1));
						}
					}
				}
				if (value.SourceStatusEffects != null)
				{
					ActionStatusInfo[] statusEffects = value.SourceStatusEffects;
					foreach (ActionStatusInfo val5 in statusEffects)
					{
						if (!((Object)(object)val5 == (Object)null))
						{
							string key2 = Limpa(val5.Name);
							dictionary[key2] = ((!dictionary.TryGetValue(key2, out var value3)) ? 1 : (value3 + 1));
						}
					}
				}
				StringBuilder stringBuilder5 = new StringBuilder();
				foreach (KeyValuePair<string, int> item in dictionary)
				{
					stringBuilder5.Append(item.Key).Append("x").Append(item.Value)
						.Append(",");
				}
				string text4 = "-";
				if (value.UseGroundEffect)
				{
					StringBuilder stringBuilder6 = new StringBuilder();
					if (value.GroundActionStatuses != null)
					{
						ActionStatusInfo[] statusEffects = value.GroundActionStatuses;
						foreach (ActionStatusInfo val6 in statusEffects)
						{
							if ((Object)(object)val6 != (Object)null)
							{
								stringBuilder6.Append(Limpa(val6.Name)).Append(",");
							}
						}
					}
					text4 = Limpa(value.GroundTargetConditions) + " dur=" + Limpa(value.GroundDuration) + (value.GroundIsInfinite ? " infinito" : "") + " maxTrg=" + value.GroundMaxNumTriggers + " status=" + stringBuilder6;
				}
				Plugin.Log.LogInfo((object)($"[ActionProps] '{text}' | tipo={value.ActionType} | beneficio={value.BenefitType} | " + $"skillType={value.SkillType} | nAlvos={num3} | alvos={stringBuilder} | " + "alcance=" + (value.UseMaxRangeOverride ? value.MaxRangeOverride.ToString() : "-") + " | alcanceBlast=" + (value.UseMaxRangeBlastOverride ? value.MaxRangeBlastOverride.ToString() : "-") + " | knockback=" + (value.UseKnockback ? value.KnockbackAmount.ToString() : "-") + " | hits=" + (value.UseMultipleHits ? value.NumHits.ToString() : "-") + " | " + $"maxChain={value.DashMaxChainCount} | " + "colisao=" + (((Object)(object)value.KnockbackCollideAction != (Object)null) ? ((Object)value.KnockbackCollideAction).name : "-") + " | hexesAtiv=" + (string.IsNullOrEmpty(value.ActivationIndicatorHexes) ? "-" : value.ActivationIndicatorHexes.Replace('\n', ',')) + " | numHitsEq=" + (value.UseNumHitsEquation ? "Sim" : "-") + " | chainProj=" + (value.ProjectileChain ? "Sim" : "Nao") + " | " + $"chainProjN={value.ProjectileChainCount} | " + "chainProjAlvo=" + Limpa(value.ProjectileChainTarget) + " | " + $"chainMesmo={value.ChainSameTarget} | " + "chainAlvo=" + Limpa(value.DashChainTarget) + " | chainMesmoAlvo=" + (value.DashChainSameTarget ? "Sim" : "Nao") + " | " + $"remocoes={((value.StatusRemovals != null) ? value.StatusRemovals.Length : 0)} | " + $"remocoesP={((value.PostActionStatusRemovals != null) ? value.PostActionStatusRemovals.Length : 0)} | " + "remocao=" + ((value.StatusRemovals != null && value.StatusRemovals.Length != 0 && (Object)(object)value.StatusRemovals[0].ActionOnRemoval != (Object)null) ? (Limpa(((Object)value.StatusRemovals[0].ActionOnRemoval).name) + "=>" + EfeitosDe(value.StatusRemovals[0].ActionOnRemoval)) : "-") + " | remocaoTipo=" + ((value.StatusRemovals != null && value.StatusRemovals.Length != 0) ? (((object)Unsafe.As<BeneficialOrHarmful, BeneficialOrHarmful>(ref value.StatusRemovals[0].BenefitType)/*cast due to .constrained prefix*/).ToString() + "/" + Limpa(value.StatusRemovals[0].NumStatusesToRemove)) : "-") + " | exprHits=" + Limpa(value.NumHitsEquation) + " | alcanceHits=" + Limpa(value.MultipleHitRange) + " | cooldown=" + Limpa(value.Cooldown) + " | cargas=" + Limpa(value.MaxCharges) + "/" + Limpa(value.InitialCharges) + " | precisa=" + Limpa(value.UseCondition) + " | condFalha=" + Limpa(value.UseConditionFailText) + " | " + $"statusAplicados={stringBuilder3} | stacks={stringBuilder5} | ground={text4} | statusFonte={stringBuilder4} | chances={stringBuilder2}"));
				if (value.Summons == null || value.Summons.Count <= 0)
				{
					continue;
				}
				StringBuilder stringBuilder7 = new StringBuilder();
				foreach (CharacterInfo summon in value.Summons)
				{
					if ((Object)(object)summon == (Object)null)
					{
						continue;
					}
					stringBuilder7.Append(Limpa(((Object)summon).name)).Append('[');
					int num5 = 0;
					if (summon.SkillsAndAI != null)
					{
						SkillAndAI[] skillsAndAI = summon.SkillsAndAI;
						foreach (SkillAndAI val7 in skillsAndAI)
						{
							if (val7 != null && (Object)(object)val7.Skill != (Object)null && !string.IsNullOrEmpty(val7.Skill.SkillName))
							{
								stringBuilder7.Append(Limpa(val7.Skill.SkillName)).Append(',');
								num5++;
							}
						}
					}
					if (num5 == 0 && summon.Skills != null)
					{
						foreach (SkillInfo skill in summon.Skills)
						{
							if ((Object)(object)skill != (Object)null && !string.IsNullOrEmpty(skill.SkillName))
							{
								stringBuilder7.Append(Limpa(skill.SkillName)).Append(',');
							}
						}
					}
					stringBuilder7.Append("]; ");
				}
				Plugin.Log.LogInfo((object)("[Summon] '" + text + "' | sorteio=" + (value.RandomSummonFromList ? "sim" : "nao") + " | herdaStats=" + (value.BenefitFromCasterStats ? "sim" : "nao") + " | morreComCaster=" + (value.DieWhenCasterDies ? "sim" : "nao") + " | persistente=" + (value.IsPersistantSummon ? "sim" : "nao") + " | doencaDeInvocacao=" + (value.HasSummoningSickness ? "sim" : "nao") + " | " + $"criaturas={stringBuilder7}"));
			}
			Plugin.Log.LogInfo((object)("[Efeitos] resumo (acoes): " + EfeitosInfo.Resumo()));
		}

		private static int ContaEfeitos(ActionInfo ac)
		{
			int num = 0;
			if ((Object)(object)ac != (Object)null && ac.Effects != null)
			{
				IEffectInfo[] effects = ac.Effects;
				for (int i = 0; i < effects.Length; i++)
				{
					if (effects[i] is GeneralEffect)
					{
						num++;
					}
				}
			}
			return num;
		}

		private static string EfeitosDe(ActionInfo ac)
		{
			StringBuilder stringBuilder = new StringBuilder();
			if ((Object)(object)ac != (Object)null && ac.Effects != null)
			{
				IEffectInfo[] effects = ac.Effects;
				foreach (IEffectInfo obj in effects)
				{
					GeneralEffect val = (GeneralEffect)(object)((obj is GeneralEffect) ? obj : null);
					if (val != null && !string.IsNullOrEmpty(val.Action))
					{
						stringBuilder.Append(Limpa(val.Action)).Append("; ");
					}
				}
			}
			return stringBuilder.ToString().TrimEnd(' ', ';');
		}

		private static void Postfix(List<SkillInfo> __result)
		{
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0482: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (_dumped || __result == null || __result.Count <= 1)
				{
					return;
				}
				if (__result.Count == _lastCount)
				{
					_stableHits++;
				}
				else
				{
					_stableHits = 1;
					_lastCount = __result.Count;
				}
				if (_stableHits < 5)
				{
					return;
				}
				_dumped = true;
				EfeitosInfo.Zerar();
				Plugin.Log.LogInfo((object)$"[Skill] Inventário: {__result.Count} skills carregados.");
				foreach (SkillInfo item in __result)
				{
					if ((Object)(object)item == (Object)null)
					{
						continue;
					}
					string text = item.Description ?? "";
					StringBuilder stringBuilder = new StringBuilder();
					if (item.ActionsGranted != null)
					{
						ActionInfo[] actionsGranted = item.ActionsGranted;
						foreach (ActionInfo val in actionsGranted)
						{
							if ((Object)(object)val != (Object)null && !string.IsNullOrEmpty(((Object)val).name))
							{
								stringBuilder.Append(Limpa(((Object)val).name)).Append("; ");
								_acoes[((Object)val).name] = val;
							}
						}
					}
					StringBuilder stringBuilder2 = new StringBuilder();
					if (item.PassiveActionStatuses != null)
					{
						ActionStatusInfo[] passiveActionStatuses = item.PassiveActionStatuses;
						foreach (ActionStatusInfo val2 in passiveActionStatuses)
						{
							if ((Object)(object)val2 != (Object)null && !string.IsNullOrEmpty(val2.Name))
							{
								stringBuilder2.Append(Limpa(val2.Name)).Append("; ");
							}
						}
					}
					StringBuilder stringBuilder3 = new StringBuilder();
					if (item.AttributeEffects != null)
					{
						CharacterEffectInfo[] attributeEffects = item.AttributeEffects;
						foreach (CharacterEffectInfo val3 in attributeEffects)
						{
							if (val3 != null && !((Object)(object)val3.CharacterAttribute == (Object)null))
							{
								stringBuilder3.Append(((Object)val3.CharacterAttribute).name).Append(':').Append(val3.CharacterEffectMethod)
									.Append(':')
									.Append(val3.Amount)
									.Append(", ");
							}
						}
					}
					string arg = EfeitosInfo.Descreve(item.AttributeEffects);
					string arg2 = ((item.SkillTags != null) ? string.Join(",", item.SkillTags) : "");
					Plugin.Log.LogInfo((object)($"[Skill] '{item.SkillName}' | tipo={item.SkillType} | dano={item.DamageType} | " + $"tier={item.Tier} | tags={arg2} | skid={item.Guid} | " + "passivo=" + (item.IsPassive ? "sim" : "nao") + " | " + $"attr={stringBuilder3} | acts={stringBuilder} | pstat={stringBuilder2} | " + $"nAttrEf={EfeitosInfo.Conta(item.AttributeEffects)} | attrTipos={arg} | " + "expr=" + Junta(item.DescriptionExpressions) + " | danoExpr=" + Junta(item.DamageExpressionOverrides) + " | upg=" + Limpa(item.UpgradeText) + " | desc=\"" + text.Replace("\n", " ") + "\""));
					if (item.SkillTriggers == null)
					{
						continue;
					}
					SkillTrigger[] skillTriggers = item.SkillTriggers;
					foreach (SkillTrigger val4 in skillTriggers)
					{
						if (val4 == null)
						{
							continue;
						}
						StringBuilder stringBuilder4 = new StringBuilder();
						if (val4.Actions != null)
						{
							ActionInfo[] actionsGranted = val4.Actions;
							foreach (ActionInfo val5 in actionsGranted)
							{
								if ((Object)(object)val5 != (Object)null && !string.IsNullOrEmpty(((Object)val5).name))
								{
									stringBuilder4.Append(Limpa(((Object)val5).name)).Append(',');
									_acoes[((Object)val5).name] = val5;
								}
							}
						}
						StringBuilder stringBuilder5 = new StringBuilder();
						if (val4.ActionStatuses != null)
						{
							ActionStatusInfo[] passiveActionStatuses = val4.ActionStatuses;
							foreach (ActionStatusInfo val6 in passiveActionStatuses)
							{
								if ((Object)(object)val6 != (Object)null)
								{
									stringBuilder5.Append(Limpa(val6.Name)).Append(',');
								}
							}
						}
						Plugin.Log.LogInfo((object)($"[Trigger] '{item.SkillName}' | tipo={val4.TriggerType} | " + "cond=" + Limpa(val4.Condition) + " | addBasicAttack=" + (val4.AddBasicAttackToActionList ? "sim" : "nao") + " | garanteUm=" + (val4.GauranteeOneAction ? "sim" : "nao") + " | chanceIgual=" + (val4.GiveAllActionsEqualChance ? "sim" : "nao") + " | " + $"chances={Junta(val4.ActionChanceEquations)} | acoes={stringBuilder4} | " + $"status={stringBuilder5} | chancesStatus={Junta(val4.ActionStatusChanceEquations)} | " + $"nEfeitos={((val4.GeneralEffects != null) ? val4.GeneralEffects.Length : 0)} | " + $"cooldownTrig={val4.Cooldown}"));
					}
				}
				Plugin.Log.LogInfo((object)("[Efeitos] resumo (skills): " + EfeitosInfo.Resumo()));
				DespejaAcoes();
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[Skill] erro no inventário: " + ex.Message));
			}
		}
	}
}