using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Jotunn.Configs;
using Jotunn.Entities;
using Jotunn.Managers;
using Jotunn.Utils;
using MT.Core.Commands;
using MT.Core.Compat;
using MT.Core.Diario;
using MT.Core.Especialidades;
using MT.Core.I18n;
using MT.Core.Mana;
using MT.Core.Touki;
using MT.Core.Vfx;
using Microsoft.CodeAnalysis;
using TMPro;
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.6.2", FrameworkDisplayName = ".NET Framework 4.6.2")]
[assembly: AssemblyCompany("MT.Core")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+a3d1e112c18dad5152e45a99f4e3179a3ca51bec")]
[assembly: AssemblyProduct("MT.Core")]
[assembly: AssemblyTitle("MT.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 MT.Core
{
	public static class CoreConfig
	{
		public enum ModoMuerte
		{
			Clasico,
			Equilibrado,
			Protegido
		}

		public enum ModoAgotamiento
		{
			Anime,
			Suave
		}

		public static ConfigEntry<float> ReservaInicial;

		public static ConfigEntry<float> ReservaMaxima;

		public static ConfigEntry<float> ReservaExponente;

		public static ConfigEntry<float> ManaPorPuntoDeExperiencia;

		public static ConfigEntry<float> BonusVaciarse;

		public static ConfigEntry<float> TalentoNacimiento;

		public static ConfigEntry<int> RanurasComida;

		public static ConfigEntry<bool> NadoRelajado;

		public static ConfigEntry<float> SaltoAhorroBase;

		public static ConfigEntry<float> CargaEntrenadaMax;

		public static ConfigEntry<float> EntrenoVelocidad;

		public static ConfigEntry<float> EntrenoMaxDia;

		public static ConfigEntry<float> DescansoMult;

		public static ConfigEntry<float> DescansoMana;

		public static ConfigEntry<float> DescansoManaLaplace;

		public static ConfigEntry<float> ProbLaplace;

		public static ConfigEntry<float> ProbLaplaceNivel;

		public static ConfigEntry<float> RegenLaplace;

		public static ConfigEntry<float> ProbGranReserva;

		public static ConfigEntry<float> RegenManaMult;

		public static ConfigEntry<float> CargaPorCuerpo;

		public static ConfigEntry<float> CargaPorToki;

		public static ConfigEntry<float> CargaTopeSinToki;

		public static ConfigEntry<float> CargaTopeConToki;

		public static ConfigEntry<float> CuerpoMinimoDespertar;

		public static ConfigEntry<float> CuerpoDespertarSeguro;

		public static ConfigEntry<float> ProbabilidadMinima;

		public static ConfigEntry<float> ProbabilidadMaxima;

		public static ConfigEntry<float> VidaCrisis;

		public static ConfigEntry<float> EnfriamientoCrisis;

		public static ConfigEntry<float> AguanteStaminaMax;

		public static ConfigEntry<float> StaminaPorNivelToki;

		public static ConfigEntry<float> SaltoCosto;

		public static ConfigEntry<float> SaltoCostoMin;

		public static ConfigEntry<float> StaminaRegenBase;

		public static ConfigEntry<float> VidaRegenBase;

		public static ConfigEntry<float> VelAtaqueBase;

		public static ConfigEntry<float> VelAtaquePorNivel;

		public static ConfigEntry<float> VelAtaqueMantoPorNivel;

		public static ConfigEntry<float> VelAtaquePunos;

		public static ConfigEntry<float> VelAtaqueTope;

		public static ConfigEntry<float> PasivaDano;

		public static ConfigEntry<float> PasivaVelocidad;

		public static ConfigEntry<float> PasivaSalto;

		public static ConfigEntry<float> PasivaStamina;

		public static ConfigEntry<float> StaminaAtaquePorNivel;

		public static ConfigEntry<float> PasivaDanoBase;

		public static ConfigEntry<float> PasivaVelocidadBase;

		public static ConfigEntry<float> PasivaSaltoBase;

		public static ConfigEntry<float> PasivaStaminaBase;

		public static ConfigEntry<float> TambaleoPorNivel;

		public static ConfigEntry<float> DominioSinManto;

		public static ConfigEntry<float> DominioConManto;

		public static ConfigEntry<float> CaidaBase;

		public static ConfigEntry<float> ToukiXpFisica;

		public static ConfigEntry<float> NadoTokiBase;

		public static ConfigEntry<float> NadoTokiPorNivel;

		public static ConfigEntry<float> LaplaceMult;

		public static ConfigEntry<float> ManaPorRango;

		public static ConfigEntry<float> ManaPorMeditacion;

		public static ConfigEntry<float> ManaPorControl;

		public static ConfigEntry<float> TopeGeneral;

		public static ConfigEntry<float> TopeDiosDragon;

		public static ConfigEntry<float> XpAlAire;

		public static ConfigEntry<float> XpGolpeObjeto;

		public static ConfigEntry<float> XpMatar;

		public static ConfigEntry<float> XpEspecialista;

		public static ConfigEntry<float> TalarBase;

		public static ConfigEntry<float> TalarPorNivel;

		public static ConfigEntry<float> TopeStamina;

		public static ConfigEntry<float> TopeMana;

		public static ConfigEntry<float> ManaPorNivelToki;

		public static ConfigEntry<float> NadoMantoPorNivel;

		public static ConfigEntry<float> DanoObjetosPorNivel;

		public static ConfigEntry<float> PunosExtra;

		public static ConfigEntry<float> CostoActivar;

		public static ConfigEntry<bool> AuraPunos;

		public static ConfigEntry<bool> LlamasParticulas;

		public static ConfigEntry<float> AuraManosTamano;

		public static ConfigEntry<float> AuraGrosor;

		public static ConfigEntry<float> AuraRelleno;

		public static ConfigEntry<float> CaidaVidaPorNivel;

		public static ConfigEntry<float> CaidaVidaMinima;

		public static ConfigEntry<float> VidaPorCuerpo;

		public static ConfigEntry<float> StaminaEntrenadaMax;

		public static ConfigEntry<float> CaidaPorNivel;

		public static ConfigEntry<float> StaminaRegenPorNivel;

		public static ConfigEntry<float> VidaMaxPorNivel;

		public static ConfigEntry<bool> TextoXp;

		public static ConfigEntry<bool> NumerosXp;

		public static ConfigEntry<float> VidaRegenPorNivel;

		public static ConfigEntry<float> VidaRegenPlanaBase;

		public static ConfigEntry<float> VidaRegenPlanaPorNivel;

		public static ConfigEntry<float> VidaRegenEnCombate;

		public static ConfigEntry<float> VidaRegenCombateSegundos;

		public static ConfigEntry<float> VidaRegenMeditandoTope;

		public static ConfigEntry<float> BarraBase;

		public static ConfigEntry<float> BarraPorNivel;

		public static ConfigEntry<float> PerdidaTransferencia;

		public static ConfigEntry<float> MantenerQuieto;

		public static ConfigEntry<float> MantenerCorriendo;

		public static ConfigEntry<float> CostoGolpe;

		public static ConfigEntry<float> CostoSalto;

		public static ConfigEntry<float> VelocidadPorNivel;

		public static ConfigEntry<float> StaminaCorrerPorNivel;

		public static ConfigEntry<float> SaltoPorNivel;

		public static ConfigEntry<float> DanoPorNivel;

		public static ConfigEntry<float> AmortiguarPorNivel;

		public static ConfigEntry<float> DurezaPorNivel;

		public static ConfigEntry<float> SalvarGolpeMortal;

		public static ConfigEntry<float> SalvarSinManto;

		public static ConfigEntry<float> VidaMantoPorNivel;

		public static ConfigEntry<float> SorpresaPorNivel;

		public static ConfigEntry<float> ControlMaxReduccion;

		public static ConfigEntry<bool> ReflejoActivo;

		public static ConfigEntry<float> HitoReflejoGolpes;

		public static ConfigEntry<float> HitoNaturalMinutos;

		public static ConfigEntry<float> HitoMaestriaDano;

		public static ConfigEntry<bool> ToukiNaturalActivo;

		public static ConfigEntry<ModoMuerte> Muerte;

		public static ConfigEntry<bool> BarraManaSiempre;

		public static ConfigEntry<bool> AuraVisible;

		public static ConfigEntry<bool> NumerosDanoColor;

		public static ConfigEntry<float> NumerosDanoRojo;

		public static ConfigEntry<bool> DebugEntrenamiento;

		public static ConfigEntry<float> BarraX;

		public static ConfigEntry<float> BarraY;

		public static ConfigEntry<float> MeditacionCosto;

		public static ConfigEntry<float> MeditacionTopeReserva;

		public static ConfigEntry<float> MeditacionMinutosDiarios;

		public static ConfigEntry<float> BuffManaPorNivel;

		public static ConfigEntry<float> BuffRegenPorNivel;

		public static ConfigEntry<ModoAgotamiento> Agotamiento;

		public static ConfigEntry<bool> DescuentosGremio;

		public static void Bind(ConfigFile cfg)
		{
			//IL_0566: Unknown result type (might be due to invalid IL or missing references)
			//IL_056b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0573: Expected O, but got Unknown
			//IL_0573: Unknown result type (might be due to invalid IL or missing references)
			//IL_057d: Expected O, but got Unknown
			//IL_0637: Unknown result type (might be due to invalid IL or missing references)
			//IL_063c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0644: Expected O, but got Unknown
			//IL_0644: Unknown result type (might be due to invalid IL or missing references)
			//IL_064e: Expected O, but got Unknown
			//IL_066d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0672: Unknown result type (might be due to invalid IL or missing references)
			//IL_067a: Expected O, but got Unknown
			//IL_067a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0684: Expected O, but got Unknown
			//IL_0b27: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b2c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b34: Expected O, but got Unknown
			//IL_0b34: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b3e: Expected O, but got Unknown
			BarraBase = Admin(cfg, "4. Manto", "BarraBase", 0.25f, "Tamaño de la barra naranja (fracción del maná máximo) = base + nivel × por nivel.");
			BarraPorNivel = Admin(cfg, "4. Manto", "BarraPorNivel", 0.05f, "Aumento del tamaño de la barra naranja por nivel de tōki.");
			PerdidaTransferencia = Admin(cfg, "4. Manto", "PerdidaTransferencia", 0.1f, "Maná que se pierde al cargar o al devolver la barra naranja.");
			MantenerQuieto = Admin(cfg, "4. Manto", "MantenerQuieto", 0.5f, "Tōki por segundo con el manto activo, quieto o caminando.");
			MantenerCorriendo = Admin(cfg, "4. Manto", "MantenerCorriendo", 1.5f, "Tōki por segundo con el manto activo, corriendo.");
			CostoGolpe = Admin(cfg, "4. Manto", "CostoGolpe", 2f, "Tōki por golpe o disparo reforzado.");
			CostoSalto = Admin(cfg, "4. Manto", "CostoSalto", 1f, "Tōki por salto reforzado.");
			VelocidadPorNivel = Admin(cfg, "4. Manto", "VelocidadPorNivel", 0.04f, "Velocidad al correr por nivel con el manto (Nv 10 → +40 %).");
			StaminaCorrerPorNivel = Admin(cfg, "4. Manto", "StaminaCorrerPorNivel", 0.04f, "Reducción de stamina al correr por nivel con el manto (Nv 10 → −40 %).");
			VelAtaqueBase = Admin(cfg, "3. Tōki pasivo", "AtaqueVelBase", 0.02f, "Velocidad de ataque extra solo por tener el tōki despierto (puños, espada y cualquier arma).");
			VelAtaquePorNivel = Admin(cfg, "3. Tōki pasivo", "AtaqueVelPorNivel", 0.01f, "Velocidad de ataque por nivel de tōki, siempre. Nv 10 → +12 % con la base.");
			VelAtaqueMantoPorNivel = Admin(cfg, "4. Manto", "AtaqueVelPorNivel", 0.015f, "Velocidad de ataque extra por nivel con el manto activo (Nv 10 → +15 %).");
			VelAtaquePunos = Admin(cfg, "4. Manto", "AtaqueVelPunos", 0.25f, "Los puños sin arma ganan este extra sobre el bonus del tōki (0,25 = +25 % del bonus).");
			VelAtaqueTope = Admin(cfg, "4. Manto", "AtaqueVelTope", 0.4f, "Tope de velocidad de ataque sumando tōki, puños y estilos de espada (0,4 = +40 %).");
			StaminaAtaquePorNivel = Admin(cfg, "4. Manto", "StaminaAtaquePorNivel", 0.04f, "Reducción de stamina al atacar por nivel con el manto (Nv 10 → −40 %).");
			SaltoPorNivel = Admin(cfg, "4. Manto", "SaltoPorNivelToki", 0.05f, "Altura de salto por nivel de tōki con el manto (Nv 10 → +50 %).");
			DanoPorNivel = Admin(cfg, "4. Manto", "DanoPorNivel", 0.05f, "Daño físico cuerpo a cuerpo por nivel con el manto (Nv 10 → +50 %; a distancia, menos).");
			PasivaDano = Admin(cfg, "3. Tōki pasivo", "DanoPorNivel", 0.015f, "Daño físico por nivel de tōki, siempre (sin manto). Nv 10 → +15 %.");
			PasivaVelocidad = Admin(cfg, "3. Tōki pasivo", "VelocidadPorNivel", 0.01f, "Velocidad al moverse por nivel de tōki, siempre. Nv 10 → +10 %.");
			PasivaSalto = Admin(cfg, "3. Tōki pasivo", "SaltoPorNivel", 0.015f, "Altura de salto por nivel de tōki, siempre. Nv 10 → +15 %.");
			PasivaStamina = Admin(cfg, "3. Tōki pasivo", "StaminaGastoPorNivel", 0.02f, "Menos stamina en todo (correr, atacar, bloquear, esquivar, nadar, sigilo, herramientas) por nivel de tōki. Se suma a la base.");
			PasivaDanoBase = Admin(cfg, "3. Tōki pasivo", "DanoBase", 0.05f, "Daño físico extra solo por tener el tōki despierto (Nv 1 → +6.5 %, Nv 10 → +20 %).");
			PasivaVelocidadBase = Admin(cfg, "3. Tōki pasivo", "VelocidadBase", 0.1f, "Velocidad extra solo por tener el tōki despierto (Nv 1 → +11 %, Nv 10 → +20 %).");
			PasivaSaltoBase = Admin(cfg, "3. Tōki pasivo", "SaltoBase", 0.05f, "Altura de salto extra solo por tener el tōki despierto (Nv 1 → +6.5 %, Nv 10 → +20 %).");
			PasivaStaminaBase = Admin(cfg, "3. Tōki pasivo", "StaminaGastoBase", 0.1f, "Menos stamina en todo solo por tener el tōki despierto (Nv 1 → −12 %, Nv 10 → −30 %).");
			TambaleoPorNivel = Admin(cfg, "3. Tōki pasivo", "TambaleoPorNivel", 0.025f, "Menos tambaleo al recibir golpes por nivel de tōki (Nv 10 → −25 %).");
			CaidaBase = Admin(cfg, "3. Tōki pasivo", "CaidaBase", 0.5f, "Menos daño de caída solo por tener el tōki despierto (+ CaidaPorNivel; tope −90 %). Lo que quede se paga con maná azul y, si no hay, con vida.");
			NadoTokiBase = Admin(cfg, "3. Tōki pasivo", "NadoPasivoBase", 0.3f, "Velocidad al nadar extra solo por tener el tōki despierto, sin manto (+30 %).");
			NadoTokiPorNivel = Admin(cfg, "3. Tōki pasivo", "NadoPasivoPorNivel", 0.05f, "Velocidad al nadar extra por nivel de tōki, sin manto (Nv 1 → +35 %, Nv 10 → +80 %).");
			DominioSinManto = Admin(cfg, "3. Tōki pasivo", "DominioSinManto", 0.15f, "Experiencia de Dominio por cada punto de experiencia física (armas, correr, saltar, nadar, bloquear, talar, picar) sin el manto.");
			DominioConManto = Admin(cfg, "3. Tōki pasivo", "DominioConManto", 0.4f, "Lo mismo con el manto activo.");
			ToukiXpFisica = Admin(cfg, "3. Tōki pasivo", "ExperienciaFisica", 2f, "Multiplicador de experiencia de las habilidades físicas (armas, correr, saltar, nadar, sigilo, bloquear, talar, picar) con el tōki despierto.");
			AmortiguarPorNivel = Admin(cfg, "4. Manto", "Amortiguar", 0.06f, "Daño físico que amortigua el manto por nivel (Nv 4 → 24 %, Nv 10 → 60 %), pagando tōki.");
			DurezaPorNivel = Admin(cfg, "3. Tōki pasivo", "DurezaPorNivel", 0.02f, "Cuerpo endurecido: daño físico recibido menos por nivel, siempre, gratis (Nv 10 → −20 %). La armadura se suma encima.");
			SalvarGolpeMortal = Admin(cfg, "4. Manto", "EnfriamientoGolpeMortal", 60f, "Con el manto activo, un golpe mortal te deja con vida (CaidaVidaMinima) gastando la barra naranja. Segundos hasta repetirlo (0 = desactivado).");
			SalvarSinManto = Admin(cfg, "3. Tōki pasivo", "EnfriamientoGolpeMortalSinManto", 180f, "Tōki despierto sin manto: también resiste un golpe mortal, con este enfriamiento menos 10 s por nivel (Nv 1 → 170 s, Nv 10 → 80 s). 0 = desactivado.");
			VidaMantoPorNivel = Admin(cfg, "4. Manto", "VidaMantoPorNivel", 0.015f, "Vida máxima extra (fracción) por nivel con el manto activo.");
			SorpresaPorNivel = Admin(cfg, "3. Tōki pasivo", "SorpresaPorNivel", 0.03f, "Reducción de daño de golpes por la espalda por nivel.");
			ControlMaxReduccion = Admin(cfg, "1. Maná", "ControlMaxReduccion", 0.4f, "Reducción de costos con Control del maná 100.");
			HitoReflejoGolpes = Admin(cfg, "5. Hitos", "ReflejoGolpes", 25f, "Reflejo (Nv 4): golpes por la espalda o caídas sobrevividos gracias al tōki.");
			HitoNaturalMinutos = Admin(cfg, "5. Hitos", "NaturalMinutos", 30f, "Tōki natural (Nv 7): minutos en total con el manto activo.");
			HitoMaestriaDano = Admin(cfg, "5. Hitos", "MaestriaDano", 10000f, "Maestría (Nv 10): daño total amortiguado con el tōki.");
			ReflejoActivo = cfg.Bind<bool>("5. Hitos", "Reflejo", true, "Nv 4: el tōki se activa solo un instante ante golpes por sorpresa y caídas (paga del maná azul).");
			ToukiNaturalActivo = cfg.Bind<bool>("5. Hitos", "ToukiNatural", true, "Nv 7: manto débil siempre activo, a cambio de reservar maná máximo.");
			Muerte = cfg.Bind<ModoMuerte>("6. Muerte", "Modo", ModoMuerte.Equilibrado, new ConfigDescription("Pérdida de las habilidades MT al morir: Clasico (como Valheim), Equilibrado (la mitad), Protegido (nada).", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = true
			} }));
			MeditacionCosto = Admin(cfg, "8. Meditación", "CostoPorSegundo", 2f, "Maná que circula (se gasta) por segundo meditando.");
			MeditacionTopeReserva = Admin(cfg, "8. Meditación", "TopeReserva", 30f, "Hasta este nivel de Reserva, meditar la hace crecer; después solo da el buff.");
			MeditacionMinutosDiarios = Admin(cfg, "8. Meditación", "MinutosDiarios", 10f, "Minutos por día del juego con experiencia completa; después, al 25 %.");
			BuffManaPorNivel = Admin(cfg, "8. Meditación", "BuffManaPorNivel", 0.03f, "Mente en calma: maná máximo extra por nivel de meditación.");
			BuffRegenPorNivel = Admin(cfg, "8. Meditación", "BuffRegenPorNivel", 0.05f, "Mente en calma: regeneración de maná extra por nivel de meditación.");
			Agotamiento = cfg.Bind<ModoAgotamiento>("9. Agotamiento", "Modo", ModoAgotamiento.Anime, new ConfigDescription("Anime: colapso, agotamiento y desmayo si se repite. Suave: solo 10 s sin regenerar maná.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = true
			} }));
			DescuentosGremio = cfg.Bind<bool>("10. Gremio", "Descuentos", true, new ConfigDescription("Descuentos con los comerciantes según el rango del Gremio.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = true
			} }));
			DebugEntrenamiento = cfg.Bind<bool>("7. Interfaz", "AvisosEntrenamiento", true, "Mostrar en pantalla y en el log lo que entrenas al golpear árboles y rocas (para pruebas).");
			BarraManaSiempre = cfg.Bind<bool>("7. Interfaz", "BarraManaSiempreVisible", true, "Mostrar siempre la barra azul de maná (el juego la oculta cuando está llena).");
			AuraVisible = cfg.Bind<bool>("7. Interfaz", "AuraToki", true, "Aura de tōki con el manto: llamas de fuego envolviendo todo el cuerpo (shader propio).");
			CaidaVidaPorNivel = Admin(cfg, "3. Tōki pasivo", "CaidaVidaPorNivel", 0.08f, "Si el maná no alcanza para la caída, lo que baja de vida se reduce esto por nivel de tōki (Nv 10 → −80 %).");
			CaidaVidaMinima = Admin(cfg, "3. Tōki pasivo", "CaidaVidaMinima", 5f, "Con el tōki despierto, una caída nunca te mata: te deja como mínimo con esta vida.");
			AuraPunos = cfg.Bind<bool>("7. Interfaz", "AuraPunos", false, "Además, brillo de fuego envolviendo cada puño.");
			AuraGrosor = cfg.Bind<float>("7. Interfaz", "AuraGrosor", 0.035f, "Cuánto sobresale el aura del cuerpo (metros).");
			AuraRelleno = cfg.Bind<float>("7. Interfaz", "AuraRelleno", 0.15f, "Llamas por dentro de la silueta: 0 = solo el contorno arde, 1 = todo el cuerpo cubierto.");
			AuraManosTamano = cfg.Bind<float>("7. Interfaz", "AuraManosTamano", 0.18f, "Tamaño del brillo de tōki en cada puño (metros).");
			LlamasParticulas = cfg.Bind<bool>("7. Interfaz", "LlamasParticulas", false, "Además, llamas de partículas saliendo del cuerpo y las manos.");
			NumerosDanoColor = cfg.Bind<bool>("7. Interfaz", "NumerosDeDanoConColor", true, "Colorear los números de daño del juego de amarillo (poco) a rojo (mucho).");
			NumerosDanoRojo = cfg.Bind<float>("7. Interfaz", "NumerosDeDanoRojoDesde", 150f, "Daño a partir del cual el número sale rojo del todo.");
			BarraX = cfg.Bind<float>("7. Interfaz", "BarraTokiX", 0.5f, "Posición horizontal de la barra naranja (0 = izquierda, 1 = derecha).");
			BarraY = cfg.Bind<float>("7. Interfaz", "BarraTokiY", 0.93f, "Posición vertical de la barra naranja (0 = arriba, 1 = abajo).");
			ReservaInicial = Admin(cfg, "1. Maná", "ReservaInicial", 10f, "Maná propio con Reserva 0.");
			ReservaMaxima = Admin(cfg, "1. Maná", "ReservaMaxima", 300f, "Maná propio con Reserva 100 (sin comida ni el resto de fuentes).");
			ManaPorRango = Admin(cfg, "1. Maná", "ManaPorRangoMagico", 1.2f, "Maná por punto de tu mejor rango mágico (0–100; Dios = 100 → +120).");
			ManaPorMeditacion = Admin(cfg, "1. Maná", "ManaPorMeditacion", 0.5f, "Maná por nivel de Meditación (100 → +50).");
			ManaPorControl = Admin(cfg, "1. Maná", "ManaPorControl", 0.3f, "Maná por nivel de Control del maná (100 → +30).");
			TopeGeneral = Admin(cfg, "1. Maná", "TopeVidaStaminaMana", 700f, "Máximo de vida, stamina y maná con todo (comida, tōki, talento…).");
			XpAlAire = Admin(cfg, "11. Experiencia", "AlAire", 0.1f, "Experiencia del arma por practicar al aire (1 ataque por segundo cuenta).");
			XpGolpeObjeto = Admin(cfg, "11. Experiencia", "GolpearObjetos", 0.3f, "Experiencia del arma al golpear árboles, rocas y objetos (2 veces por segundo como mucho).");
			XpMatar = Admin(cfg, "11. Experiencia", "Matar", 1f, "Experiencia extra del arma al matar (× vida del enemigo / 50, entre 0.5 y 6; jefes ×3).");
			XpEspecialista = Admin(cfg, "11. Experiencia", "Especialista", 1.25f, "Tu arma principal (habilidad de combate más alta) gana esta experiencia extra.");
			TalarBase = Admin(cfg, "3. Tōki pasivo", "TalarBase", 0.4f, "Con el tōki despierto, parte del daño físico de cualquier golpe también tala árboles y pica rocas (40 % + TalarPorNivel).");
			TalarPorNivel = Admin(cfg, "3. Tōki pasivo", "TalarPorNivel", 0.06f, "Por nivel de tōki (Nv 10 → 100 %). La fuerza cuenta como herramienta de nivel 1 + nivel/2.");
			TopeStamina = Admin(cfg, "1. Maná", "TopeStamina", 700f, "Máximo de stamina con todo (comida, tōki, entrenamiento).");
			TopeMana = Admin(cfg, "1. Maná", "TopeMana", 700f, "Máximo de maná con todo (comida, reserva, tōki, talento).");
			ManaPorNivelToki = Admin(cfg, "3. Tōki pasivo", "ManaPorNivelToki", 15f, "Maná máximo extra por nivel de tōki (Nv 10 → +150). El tōki también es maná.");
			NadoMantoPorNivel = Admin(cfg, "4. Manto", "NadoPorNivel", 0.04f, "Velocidad al nadar por nivel con el manto (Nv 10 → +40 %), además de la pasiva.");
			DanoObjetosPorNivel = Admin(cfg, "4. Manto", "DanoObjetosPorNivel", 0.05f, "Daño a árboles, rocas y objetos por nivel con el manto (Nv 10 → +50 %).");
			PunosExtra = Admin(cfg, "4. Manto", "MultiplicadorPunos", 1.5f, "Los puños aprovechan más el tōki: su bonus de daño se multiplica por esto.");
			CostoActivar = Admin(cfg, "4. Manto", "CostoActivar", 10f, "Maná azul que cuesta encender el manto (aparte de lo que pasa a la barra naranja).");
			TopeDiosDragon = Admin(cfg, "1. Maná", "TopeDiosDragon", 1000f, "Máximo de vida, stamina y maná con el Dios Dragón.");
			ReservaExponente = Admin(cfg, "1. Maná", "ReservaExponente", 0.7f, "Curva de la reserva: menor = crece más rápido al principio.");
			ManaPorPuntoDeExperiencia = Admin(cfg, "1. Maná", "ManaPorPuntoDeExperiencia", 5f, "Maná gastado para ganar 1 punto de experiencia de Reserva.");
			BonusVaciarse = Admin(cfg, "1. Maná", "BonusVaciarse", 1.25f, "Multiplicador de experiencia si el gasto te deja por debajo del 10 % de maná.");
			NadoRelajado = Admin2(cfg, "8. Meditación", "NadoRelajado", value: true, "Nadar despacio no gasta stamina y la recupera; solo nadar rápido (correr) la gasta. Sin muerte por ahogo.");
			RanurasComida = cfg.Bind<int>("8. Meditación", "RanurasComida", 5, new ConfigDescription("Comidas distintas que puedes tener a la vez (Valheim: 3). Entre 3 y 8.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(3, 8), new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = true
			} }));
			SaltoAhorroBase = Admin(cfg, "3. Tōki pasivo", "SaltoAhorroBase", 0.5f, "(Ya no se usa: ver SaltoCosto.)");
			SaltoCosto = Admin(cfg, "3. Tōki pasivo", "SaltoCosto", 2f, "Stamina por salto sin tōki y sin entrenar (Valheim: 10). Con el manto activo: 0.");
			SaltoCostoMin = Admin(cfg, "3. Tōki pasivo", "SaltoCostoMinimo", 1f, "Stamina por salto muy entrenado (Saltar + Aguante = 100) o con el tōki despierto.");
			CargaEntrenadaMax = Admin(cfg, "3. Tōki pasivo", "CargaEntrenadaTope", 100f, "Peso extra que se gana entrenando (+1 a +5 por esfuerzo). Con cuerpo (+50) y tōki (+50), el total llega a +200.");
			EntrenoVelocidad = Admin(cfg, "3. Tōki pasivo", "VelocidadEntrenamiento", 1f, "Multiplicador de lo rápido que crece el cuerpo entrenando (stamina entrenada y Aguante).");
			EntrenoMaxDia = Admin(cfg, "3. Tōki pasivo", "StaminaEntrenadaPorDia", 15f, "Máximo de stamina que se gana entrenando por día del juego.");
			DescansoMana = Admin(cfg, "8. Meditación", "DescansoManaFuerza", 6f, "El bonus de descanso vale esto más para el maná (6 → Descansado ×2.5, sentado ×4, junto al fuego ×5.5, en la cama ×8.5).");
			DescansoManaLaplace = Admin(cfg, "8. Meditación", "DescansoManaLaplace", 1.5f, "Con el Factor de Laplace, el bonus de descanso del maná es aún mayor (1.5 → sentado ×5.5, fuego ×7.75, cama ×12.25).");
			DescansoMult = Admin(cfg, "8. Meditación", "Descanso", 1f, "Fuerza del bonus de descanso (1 = normal, 0 = sin bonus). Descansado +25 %, sentado +50 %, junto al fuego +25 %, en la cama +100 % a toda la regeneración.");
			ProbLaplace = Admin(cfg, "1. Maná", "ProbFactorLaplace", 0.015f, "Probabilidad de nacer con el Factor de Laplace (reserva ×2.5, sin tōki).");
			LaplaceMult = Admin(cfg, "1. Maná", "ReservaLaplace", 1.7f, "Multiplicador de la reserva con el Factor de Laplace (1.7 ≈ 255 de maná propio con Reserva 100). Su Reserva crece +50 % más rápido.");
			ProbLaplaceNivel = Admin(cfg, "1. Maná", "ProbLaplacePorNivel", 0.005f, "Probabilidad de despertar el Factor de Laplace cada vez que sube la Reserva (solo con el tōki dormido).");
			RegenLaplace = Admin(cfg, "1. Maná", "RegeneracionLaplaceExtra", 1.25f, "Factor de Laplace: su regeneración escala con su reserva (×ReservaLaplace) y además se multiplica por esto (1.25 = +25 %): se llena antes que la de un mago normal.");
			ProbGranReserva = Admin(cfg, "1. Maná", "ProbGranReserva", 0.2f, "Probabilidad de nacer con gran reserva (×1.5).");
			RegenManaMult = Admin(cfg, "1. Maná", "RegeneracionMana", 0.6f, "Multiplicador de la regeneración de maná (0.6 = −40 %: menos magia, más estrategia).");
			CargaPorCuerpo = Admin(cfg, "3. Tōki pasivo", "CargaPorNivelDeCuerpo", 1f, "Peso que puedes cargar por punto de Nivel de Cuerpo (100 → +100). Con el entrenamiento: +200 sin tōki.");
			CargaTopeSinToki = Admin(cfg, "3. Tōki pasivo", "CargaExtraTopeSinToki", 200f, "Máximo peso extra que da MT sin tōki. Mochilas de otros mods suman aparte.");
			CargaTopeConToki = Admin(cfg, "3. Tōki pasivo", "CargaExtraTopeConToki", 600f, "Máximo peso extra que da MT con tōki. Mochilas de otros mods suman aparte.");
			CargaPorToki = Admin(cfg, "3. Tōki pasivo", "CargaPorNivelDeToki", 40f, "Peso que puedes cargar por nivel de tōki (10 → +400; +600 en total).");
			TalentoNacimiento = Admin(cfg, "2. Despertar", "TalentoNacimiento", 0.01f, "Probabilidad (una sola tirada por personaje) de nacer con el tōki despierto.");
			CuerpoMinimoDespertar = Admin(cfg, "2. Despertar", "CuerpoMinimo", 12f, "Nivel de Cuerpo desde el que puede despertar el tōki.");
			CuerpoDespertarSeguro = Admin(cfg, "2. Despertar", "CuerpoTope", 25f, "Nivel de Cuerpo en el que la probabilidad de despertar llega a su tope (99 %). Nunca es seguro.");
			ProbabilidadMinima = Admin(cfg, "2. Despertar", "ProbabilidadMinima", 0.03f, "Probabilidad por tirada con el Cuerpo mínimo.");
			ProbabilidadMaxima = Admin(cfg, "2. Despertar", "ProbabilidadTope", 0.99f, "Probabilidad por tirada con el Nivel de Cuerpo tope (máx. 0.99: nunca es 100 %).");
			VidaCrisis = Admin(cfg, "2. Despertar", "VidaCrisis", 0.2f, "Momento de crisis: sobrevivir con menos de esta fracción de vida da una tirada doble.");
			EnfriamientoCrisis = Admin(cfg, "2. Despertar", "EnfriamientoCrisis", 600f, "Segundos entre tiradas de crisis.");
			StaminaEntrenadaMax = Admin(cfg, "3. Tōki pasivo", "StaminaEntrenadaMax", 60f, "Stamina máxima que se gana entrenando (esfuerzos de verdad), aparte del Aguante. Con Aguante: +200 sin tōki.");
			VidaPorCuerpo = Admin(cfg, "3. Tōki pasivo", "VidaPorNivelDeCuerpo", 0.2f, "Vida máxima extra por punto de Nivel de Cuerpo (100 → +20), con o sin tōki.");
			AguanteStaminaMax = Admin(cfg, "3. Tōki pasivo", "AguanteStaminaMax", 140f, "Stamina máxima extra con Aguante 100 (crece más rápido al principio).");
			StaminaPorNivelToki = Admin(cfg, "3. Tōki pasivo", "StaminaPorNivelToki", 30f, "Stamina máxima extra por nivel de tōki (Nv 10 → +300; con el resto, +500 en total).");
			CaidaPorNivel = Admin(cfg, "3. Tōki pasivo", "CaidaPorNivel", 0.05f, "Reducción de daño de caída por nivel de tōki.");
			StaminaRegenBase = Admin(cfg, "3. Tōki pasivo", "StaminaRegenBase", 0.5f, "Regeneración de stamina extra solo por tener el tōki despierto (0.50 = +50 %).");
			StaminaRegenPorNivel = Admin(cfg, "3. Tōki pasivo", "StaminaRegenPorNivel", 0.05f, "Regeneración de stamina extra por nivel (Nv 1 → +55 %, Nv 10 → +100 %).");
			TextoXp = cfg.Bind<bool>("Interfaz", "TextoExperiencia", true, "Flechitas «↑» sobre el personaje al ganar experiencia o entrenamiento.");
			NumerosXp = cfg.Bind<bool>("Interfaz", "NumerosExperiencia", false, "Además de las flechitas, el número «+N XP». Apagado por defecto: el progreso se lee en el Diario (F8).");
			VidaMaxPorNivel = Admin(cfg, "3. Tōki pasivo", "VidaMaxPorNivel", 15f, "Vida máxima extra por nivel de tōki (Nv 10 → +150).");
			VidaRegenBase = Admin(cfg, "3. Tōki pasivo", "VidaRegenBase", 0.25f, "Regeneración de vida extra solo por tener el tōki despierto (0.25 = +25 %).");
			VidaRegenPorNivel = Admin(cfg, "3. Tōki pasivo", "VidaRegenPorNivel", 0.03f, "Regeneración de vida extra por nivel (Nv 1 → +28 %, Nv 10 → +55 %).");
			VidaRegenPlanaBase = Admin(cfg, "3. Tōki pasivo", "VidaRegenPlanaBase", 0.001f, "Vida que regeneras por segundo, en fracción de la vida máxima, solo por tener el tōki despierto (0.001 = 0,1 %/s), aunque no hayas comido.");
			VidaRegenPlanaPorNivel = Admin(cfg, "3. Tōki pasivo", "VidaRegenPlanaPorNivel", 0.0002f, "Vida por segundo extra por nivel de tōki (Nv 10 → 0,3 %/s de la vida máxima).");
			VidaRegenEnCombate = Admin(cfg, "3. Tōki pasivo", "VidaRegenEnCombate", 0.25f, "En combate (te golpearon hace poco) la regeneración propia del tōki se multiplica por esto (0.25 = un cuarto).");
			VidaRegenCombateSegundos = Admin(cfg, "3. Tōki pasivo", "VidaRegenCombateSegundos", 8f, "Segundos sin recibir daño para volver a regenerar del todo.");
			VidaRegenMeditandoTope = Admin(cfg, "3. Tōki pasivo", "VidaRegenMeditandoTope", 0.003f, "Meditando se regenera el doble, hasta este tope por segundo (0.003 = 0,3 %/s de la vida máxima).");
		}

		private static ConfigEntry<bool> Admin2(ConfigFile cfg, string section, string key, bool value, string description)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			return cfg.Bind<bool>(section, key, value, new ConfigDescription(description, (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = true
			} }));
		}

		private static ConfigEntry<float> Admin(ConfigFile cfg, string section, string key, float value, string description)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			return cfg.Bind<float>(section, key, value, new ConfigDescription(description, (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = true
			} }));
		}
	}
	public static class Estado
	{
		public static bool Levitando;
	}
	[BepInPlugin("mushokutensei.core", "MT Core", "1.8.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	[SynchronizationMode(/*Could not decode attribute arguments.*/)]
	public class MTCorePlugin : BaseUnityPlugin
	{
		public const string Guid = "mushokutensei.core";

		public const string Version = "1.8.0";

		public static ManualLogSource Log;

		private static void Paso(string que, Action accion)
		{
			try
			{
				accion();
			}
			catch (Exception arg)
			{
				Log.LogError((object)$"MT Core: falló «{que}» al cargar (el resto sigue): {arg}");
			}
		}

		private void Awake()
		{
			//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
			Tr.Load(typeof(MTCorePlugin).Assembly, Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location));
			Log = ((BaseUnityPlugin)this).Logger;
			CoreConfig.Bind(((BaseUnityPlugin)this).Config);
			MTKeys.Bind(((BaseUnityPlugin)this).Config);
			string iconDir = Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location), "Icons");
			MTSkills.Register(iconDir);
			SE_ToukiPasivo.Register(MTSkills.LoadIcon(iconDir, "insignia_toki_despierto") ?? MTSkills.LoadIcon(iconDir, "touki_pasivo"));
			SE_Talento.Register(iconDir);
			SE_MenteEnCalma.Register(MTSkills.LoadIcon(iconDir, "mente_en_calma"));
			SE_Agotamiento.Register(MTSkills.LoadIcon(iconDir, "agotamiento"));
			Paso("teclas del manto", MantoController.RegisterInput);
			Paso("tecla de meditar", Meditacion.RegisterInput);
			((Component)this).gameObject.AddComponent<MantoController>();
			((Component)this).gameObject.AddComponent<Meditacion>();
			((Component)this).gameObject.AddComponent<EspecialidadesController>();
			((Component)this).gameObject.AddComponent<NadoController>();
			((Component)this).gameObject.AddComponent<ProgresoFisico>();
			MTBundle.Load(Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location));
			((Component)this).gameObject.AddComponent<ToukiAura>();
			((Component)this).gameObject.AddComponent<ToukiManos>();
			((Component)this).gameObject.AddComponent<ToukiPunos>();
			((Component)this).gameObject.AddComponent<ToukiCuerpo>();
			Paso("diario", delegate
			{
				PaginasCore.Registrar();
				((Component)this).gameObject.AddComponent<DiarioVentana>();
			});
			CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new AliasCommand("mt_status", "Show mana, Body Level and Toki", (ConsoleCommand)(object)new EstadoCommand()));
			CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new AliasCommand("mt_specialties", "Show your specialties, ranks and the Guild", (ConsoleCommand)(object)new EspecialidadesCommand()));
			CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new AliasCommand("mt_awaken", "[cheat] Awaken your Toki now", (ConsoleCommand)(object)new DespertarCommand()));
			CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new AliasCommand("mt_sleep", "[cheat] Put your Toki back to sleep (to test the awakening again)", (ConsoleCommand)(object)new DormirCommand()));
			CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new AliasCommand("mt_level", "[cheat] mt_level <reserve|control|mastery|meditation> <0-100>", (ConsoleCommand)(object)new NivelCommand()));
			CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new AliasCommand("mt_boss", "[cheat] mt_boss <key> — register a defeated boss (e.g. defeated_eikthyr)", (ConsoleCommand)(object)new JefeCommand()));
			CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new AliasCommand("mt_milestone", "[cheat] mt_milestone <reflex|natural|mastery> — complete a milestone achievement (still needs the Toki level)", (ConsoleCommand)(object)new HitoCommand()));
			CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new AliasCommand("mt_talent", "[cheat] mt_talent <normal|greatreserve|laplace> — change your birth talent", (ConsoleCommand)(object)new TalentoCommand()));
			CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new ManaCommand());
			CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new AliasCommand("mt_dragon_god", "[cheat] mt_dragon_god <on|off> — force the Dragon God caps (1000 health, stamina and mana) for testing", (ConsoleCommand)(object)new DiosDragonCommand()));
			new Harmony("mushokutensei.core").PatchAll();
			ModCompat.Report();
			Log.LogInfo((object)"MT Core 1.8.0 cargado");
		}
	}
	public static class MTGui
	{
		public static readonly Color Oro = new Color(1f, 0.72f, 0.36f);

		public static readonly Color Texto = new Color(0.93f, 0.9f, 0.84f);

		public static readonly Color Gris = new Color(0.65f, 0.63f, 0.6f);

		public static readonly Color Naranja = new Color(1f, 0.55f, 0.12f);

		public static readonly Color Azul = new Color(0.45f, 0.7f, 1f);

		public static readonly Color Rojo = new Color(1f, 0.35f, 0.3f);

		private static Font _font;

		private static float _fontRetry;

		private static Texture2D _white;

		private static Texture2D _panel;

		private static Texture2D _border;

		private static GUIStyle _style;

		private static readonly string[] SinAveria = new string[6] { "Russian", "Ukrainian", "Chinese", "Chinese_Trad", "Japanese", "Korean" };

		public static float Scale => Mathf.Clamp((float)Screen.height / 1080f, 0.75f, 2f);

		private static Font ValheimFont()
		{
			if (Array.IndexOf(SinAveria, Tr.Current) >= 0)
			{
				return null;
			}
			if ((Object)(object)_font != (Object)null)
			{
				return _font;
			}
			if (Time.unscaledTime < _fontRetry)
			{
				return null;
			}
			_fontRetry = Time.unscaledTime + 5f;
			Font[] source = Resources.FindObjectsOfTypeAll<Font>();
			_font = ((IEnumerable<Font>)source).FirstOrDefault((Func<Font, bool>)((Font f) => ((Object)f).name.Contains("AveriaSerifLibre-Bold"))) ?? ((IEnumerable<Font>)source).FirstOrDefault((Func<Font, bool>)((Font f) => ((Object)f).name.StartsWith("Averia"))) ?? ((IEnumerable<Font>)source).FirstOrDefault((Func<Font, bool>)((Font f) => ((Object)f).name.Contains("Norse")));
			return _font;
		}

		private static Texture2D Solid(Color c)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			Texture2D val = new Texture2D(1, 1)
			{
				hideFlags = (HideFlags)61
			};
			val.SetPixel(0, 0, c);
			val.Apply();
			return val;
		}

		private static void Init()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_white != (Object)null))
			{
				_white = Solid(Color.white);
				_panel = Solid(new Color(0.08f, 0.07f, 0.06f, 0.78f));
				_border = Solid(new Color(0.55f, 0.4f, 0.2f, 0.9f));
			}
		}

		public static GUIStyle Style(int size, Color color, TextAnchor anchor = (TextAnchor)3, bool bold = false)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			Init();
			if (_style == null)
			{
				_style = new GUIStyle(GUI.skin.label)
				{
					richText = true,
					wordWrap = false
				};
			}
			_style.font = ValheimFont();
			_style.fontSize = Mathf.RoundToInt((float)size * Scale);
			_style.fontStyle = (FontStyle)(bold ? 1 : 0);
			_style.alignment = anchor;
			_style.normal.textColor = color;
			return _style;
		}

		public static void Label(Rect r, string text, int size, Color color, TextAnchor anchor = (TextAnchor)3, bool bold = false)
		{
			//IL_0015: 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)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			GUIStyle val = Style(size, new Color(0f, 0f, 0f, 0.85f), anchor, bold);
			GUI.Label(new Rect(((Rect)(ref r)).x + 1.5f, ((Rect)(ref r)).y + 1.5f, ((Rect)(ref r)).width, ((Rect)(ref r)).height), StripColors(text), val);
			val = Style(size, color, anchor, bold);
			GUI.Label(r, text, val);
		}

		private static string StripColors(string s)
		{
			return Regex.Replace(s, "<color=[^>]*>|</color>", "");
		}

		public static void Panel(Rect r)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			Init();
			GUI.color = Color.white;
			GUI.DrawTexture(new Rect(((Rect)(ref r)).x - 2f, ((Rect)(ref r)).y - 2f, ((Rect)(ref r)).width + 4f, ((Rect)(ref r)).height + 4f), (Texture)(object)_border);
			GUI.DrawTexture(r, (Texture)(object)_panel);
		}

		public static void Bar(Rect r, float fill, Color color)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			Init();
			fill = Mathf.Clamp01(fill);
			GUI.color = new Color(0.55f, 0.4f, 0.2f, 0.9f);
			GUI.DrawTexture(new Rect(((Rect)(ref r)).x - 2f, ((Rect)(ref r)).y - 2f, ((Rect)(ref r)).width + 4f, ((Rect)(ref r)).height + 4f), (Texture)(object)_white);
			GUI.color = new Color(0.05f, 0.05f, 0.05f, 0.85f);
			GUI.DrawTexture(r, (Texture)(object)_white);
			GUI.color = color;
			GUI.DrawTexture(new Rect(((Rect)(ref r)).x, ((Rect)(ref r)).y, ((Rect)(ref r)).width * fill, ((Rect)(ref r)).height), (Texture)(object)_white);
			GUI.color = new Color(1f, 1f, 1f, 0.25f);
			GUI.DrawTexture(new Rect(((Rect)(ref r)).x, ((Rect)(ref r)).y, ((Rect)(ref r)).width * fill, ((Rect)(ref r)).height * 0.35f), (Texture)(object)_white);
			GUI.color = Color.white;
		}

		public static void Icon(Rect r, Sprite sprite, float alpha = 1f)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//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_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: 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)
			if (!((Object)(object)sprite == (Object)null))
			{
				Color color = GUI.color;
				GUI.color = new Color(1f, 1f, 1f, alpha * color.a);
				Texture2D texture = sprite.texture;
				Rect textureRect = sprite.textureRect;
				GUI.DrawTextureWithTexCoords(r, (Texture)(object)texture, new Rect(((Rect)(ref textureRect)).x / (float)((Texture)texture).width, ((Rect)(ref textureRect)).y / (float)((Texture)texture).height, ((Rect)(ref textureRect)).width / (float)((Texture)texture).width, ((Rect)(ref textureRect)).height / (float)((Texture)texture).height));
				GUI.color = color;
			}
		}

		public static string Hex(Color c)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return ColorUtility.ToHtmlStringRGB(c);
		}
	}
	public static class MTKeys
	{
		public static ConfigEntry<KeyCode> Manto;

		public static ConfigEntry<KeyCode> Meditar;

		public static ConfigEntry<KeyCode> Paso;

		public static ConfigEntry<KeyCode> Lanzar;

		public static ConfigEntry<KeyCode> SiguienteHechizo;

		public static ConfigEntry<KeyCode> OcultarHechizo;

		public static ConfigEntry<KeyCode> MenuHechizos;

		public static ConfigEntry<KeyCode> Levitar;

		public static ConfigEntry<KeyCode> Aterrizar;

		public static ConfigEntry<KeyCode> Diario;

		public static void Bind(ConfigFile cfg)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			Manto = cfg.Bind<KeyCode>("0. Teclas", "Manto", (KeyCode)282, "Cargar el manto de tōki (mantener para apagarlo).");
			Meditar = cfg.Bind<KeyCode>("0. Teclas", "Meditar", (KeyCode)104, "Meditar / dejar de meditar. Sentarse con X solo descansa (recupera maná sin gastarlo).");
			if ((int)Meditar.Value == 0)
			{
				Meditar.Value = (KeyCode)104;
			}
			Paso = cfg.Bind<KeyCode>("0. Teclas", "PasoDeToki", (KeyCode)284, "Paso de Tōki (mod MT Paso).");
			Lanzar = cfg.Bind<KeyCode>("0. Teclas", "LanzarHechizoTecla", (KeyCode)0, "Tecla opcional para lanzar el hechizo seleccionado (MT Magia). Por defecto ninguna: se lanza con el clic izquierdo y la varita o el bastón. F4 queda libre.");
			SiguienteHechizo = cfg.Bind<KeyCode>("0. Teclas", "SiguienteHechizo", (KeyCode)280, "Siguiente hechizo; con Alt, el anterior (mod MT Magia).");
			MenuHechizos = cfg.Bind<KeyCode>("0. Teclas", "MenuHechizos", (KeyCode)290, "Abrir o cerrar el menú del grimorio: todos tus hechizos y los 9 favoritos (mod MT Magia).");
			Levitar = cfg.Bind<KeyCode>("0. Teclas", "Levitar", (KeyCode)106, "Empezar a levitar (necesitas conocer Levitar, su rango y un foco en la mano) (mod MT Magia).");
			Aterrizar = cfg.Bind<KeyCode>("0. Teclas", "Aterrizar", (KeyCode)107, "Dejar de levitar y bajar sin daño de caída (mod MT Magia).");
			Diario = cfg.Bind<KeyCode>("0. Teclas", "Diario", (KeyCode)289, "Abrir o cerrar el Diario del aventurero: crónica, cuerpo y tōki, magia, espada y recetas.");
			OcultarHechizo = cfg.Bind<KeyCode>("0. Teclas", "OcultarHechizo", (KeyCode)281, "Ocultar/activar el hechizo seleccionado en el grimorio; con Alt, mostrar u ocultar la lista de ocultos (mod MT Magia).");
		}

		public static bool Down(ConfigEntry<KeyCode> k)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return ZInput.GetKeyDown(k.Value, false);
		}

		public static bool Held(ConfigEntry<KeyCode> k)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return ZInput.GetKey(k.Value, false);
		}

		public static bool Up(ConfigEntry<KeyCode> k)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return ZInput.GetKeyUp(k.Value, false);
		}
	}
	public static class MTSkills
	{
		public static SkillType Reserva;

		public static SkillType Control;

		public static SkillType Dominio;

		public static SkillType Meditacion;

		public static SkillType Aguante;

		public static void Register(string iconDir)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: 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_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			Reserva = Add("reserva", Tr.Token("core_skill_reserva"), Tr.Token("core_skill_reserva_d"), iconDir);
			Control = Add("control", Tr.Token("core_skill_control"), Tr.Token("core_skill_control_d"), iconDir);
			Dominio = Add("dominio", Tr.Token("core_skill_dominio"), Tr.Token("core_skill_dominio_d"), iconDir);
			Aguante = Add("aguante", Tr.Token("core_skill_aguante"), Tr.Token("core_skill_aguante_d"), iconDir);
			Meditacion = Add("meditacion", Tr.Token("core_skill_meditacion"), Tr.Token("core_skill_meditacion_d"), iconDir);
		}

		private static SkillType Add(string id, string name, string description, string iconDir)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			return SkillManager.Instance.AddSkill(new SkillConfig
			{
				Identifier = "mushokutensei.core." + id,
				Name = name,
				Description = description,
				Icon = LoadIcon(iconDir, id),
				IncreaseStep = 1f
			});
		}

		public static Sprite LoadIcon(string iconDir, string name)
		{
			string text = Path.Combine(iconDir, name + ".png");
			if (!File.Exists(text))
			{
				return null;
			}
			return AssetUtils.LoadSpriteFromFile(text);
		}
	}
	[HarmonyPatch(typeof(DamageText), "AddInworldText")]
	public static class NumerosDanoPatch
	{
		private static readonly Color Amarillo = new Color(1f, 0.92f, 0.35f);

		private static readonly Color Naranja = new Color(1f, 0.6f, 0.15f);

		private static readonly Color Rojo = new Color(1f, 0.2f, 0.15f);

		private static void Postfix(DamageText __instance, TextType type, string text)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Invalid comparison between Unknown and I4
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Invalid comparison between Unknown and I4
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Invalid comparison between Unknown and I4
			//IL_00ea: 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)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			if (!CoreConfig.NumerosDanoColor.Value || ((int)type != 0 && (int)type != 2 && (int)type != 1 && (int)type != 7) || (!float.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out var result) && !float.TryParse(text, NumberStyles.Float, CultureInfo.CurrentCulture, out result)))
			{
				return;
			}
			IList value = Traverse.Create((object)__instance).Field("m_worldTexts").GetValue<IList>();
			if (value != null && value.Count != 0)
			{
				TMP_Text value2 = Traverse.Create(value[value.Count - 1]).Field("m_textField").GetValue<TMP_Text>();
				if (!((Object)(object)value2 == (Object)null))
				{
					float num = Mathf.InverseLerp(Mathf.Log(5f), Mathf.Log(CoreConfig.NumerosDanoRojo.Value), Mathf.Log(Mathf.Max(result, 1f)));
					Color color = ((num < 0.5f) ? Color.Lerp(Amarillo, Naranja, num * 2f) : Color.Lerp(Naranja, Rojo, (num - 0.5f) * 2f));
					color.a = ((Graphic)value2).color.a;
					((Graphic)value2).color = color;
				}
			}
		}
	}
	public static class Rangos
	{
		public const int Count = 7;

		public static string[] Names
		{
			get
			{
				string[] array = new string[7];
				for (int i = 0; i < 7; i++)
				{
					array[i] = Name(i);
				}
				return array;
			}
		}

		public static string Name(int rank)
		{
			return Tr.Get("core_rank_" + rank);
		}
	}
	public static class Topes
	{
		private const string Key = "MT.Core.DiosDragon";

		public static Func<Player, bool> DiosDragonCheck;

		public static bool IsDiosDragon(Player p)
		{
			if ((Object)(object)p != (Object)null)
			{
				if (!p.m_customData.ContainsKey("MT.Core.DiosDragon"))
				{
					return DiosDragonCheck?.Invoke(p) ?? false;
				}
				return true;
			}
			return false;
		}

		public static float Cap(Player p)
		{
			if (!IsDiosDragon(p))
			{
				return CoreConfig.TopeGeneral.Value;
			}
			return CoreConfig.TopeDiosDragon.Value;
		}

		public static float CapStamina(Player p)
		{
			if (!IsDiosDragon(p))
			{
				return CoreConfig.TopeStamina.Value;
			}
			return CoreConfig.TopeDiosDragon.Value;
		}

		public static float CapMana(Player p)
		{
			if (!IsDiosDragon(p))
			{
				return CoreConfig.TopeMana.Value;
			}
			return CoreConfig.TopeDiosDragon.Value;
		}

		public static void SetForced(Player p, bool on)
		{
			if (on)
			{
				p.m_customData["MT.Core.DiosDragon"] = "1";
			}
			else
			{
				p.m_customData.Remove("MT.Core.DiosDragon");
			}
		}
	}
	public class DiosDragonCommand : ConsoleCommand
	{
		public override string Name => "mt_dragon_god";

		public override string Help => "[cheat] mt_dragon_god <on|off> — force the Dragon God caps (1000 health, stamina and mana) for testing";

		public override bool IsCheat => true;

		public override void Run(string[] args)
		{
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null))
			{
				if (args.Length != 0)
				{
					Topes.SetForced(localPlayer, args[0].ToLowerInvariant() != "off");
				}
				string text = (Topes.IsDiosDragon(localPlayer) ? Tr.Get("core_yes") : Tr.Get("core_no"));
				Console.instance.Print(Tr.Get("core_dragon_god_caps_health_stamina", text, Topes.Cap(localPlayer), Topes.CapStamina(localPlayer), Topes.CapMana(localPlayer)));
			}
		}
	}
	public static class XpTexto
	{
		public static readonly Color Oro = new Color(1f, 0.85f, 0.3f);

		public static readonly Color Cian = new Color(0.45f, 0.9f, 1f);

		private static float _ultimo;

		private static Material _mat;

		public static void Mostrar(Player p, string texto, Color color, int flechas = 6, bool conTexto = false)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)p == (Object)null || !CoreConfig.TextoXp.Value || Time.time - _ultimo < 0.15f)
			{
				return;
			}
			_ultimo = Time.time;
			Flechas(p, color, flechas);
			Explicar(p, color == Cian);
			if (!conTexto || !CoreConfig.NumerosXp.Value || (Object)(object)DamageText.instance == (Object)null)
			{
				return;
			}
			Vector3 val = ((Character)p).GetTopPoint() + Vector3.up * 0.3f;
			DamageText.instance.ShowText((TextType)7, val, texto, true);
			IList value = Traverse.Create((object)DamageText.instance).Field("m_worldTexts").GetValue<IList>();
			if (value != null && value.Count != 0)
			{
				TMP_Text value2 = Traverse.Create(value[value.Count - 1]).Field("m_textField").GetValue<TMP_Text>();
				if ((Object)(object)value2 != (Object)null)
				{
					((Graphic)value2).color = new Color(color.r, color.g, color.b, ((Graphic)value2).color.a);
				}
			}
		}

		private static void Explicar(Player p, bool cuerpo)
		{
			string key = (cuerpo ? "MT.Core.AvisoFlechas.Cuerpo" : "MT.Core.AvisoFlechas.Espada");
			p.m_customData.TryGetValue(key, out var value);
			int.TryParse(value, out var result);
			if (result < 3)
			{
				p.m_customData[key] = (result + 1).ToString();
				((Character)p).Message((MessageType)1, Tr.Get(cuerpo ? "core_xp_arrows_body_hint" : "core_xp_arrows_sword_hint"), 0, (Sprite)null, false);
			}
		}

		private static void Flechas(Player p, Color color, int count)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Expected O, but got Unknown
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			Material val = Material();
			if (!((Object)(object)val == (Object)null))
			{
				GameObject val2 = new GameObject("MT_XpFlechas");
				val2.transform.SetParent(((Component)p).transform, false);
				val2.transform.localPosition = Vector3.up * 0.3f;
				ParticleSystem val3 = val2.AddComponent<ParticleSystem>();
				val3.Stop(true, (ParticleSystemStopBehavior)0);
				MainModule main = val3.main;
				((MainModule)(ref main)).loop = false;
				((MainModule)(ref main)).duration = 0.4f;
				((MainModule)(ref main)).startLifetime = new MinMaxCurve(0.9f, 1.4f);
				((MainModule)(ref main)).startSpeed = new MinMaxCurve(0.9f, 1.6f);
				((MainModule)(ref main)).startSize = new MinMaxCurve(0.12f, 0.2f);
				((MainModule)(ref main)).startColor = new MinMaxGradient(color, Color.Lerp(color, Color.white, 0.5f));
				((MainModule)(ref main)).simulationSpace = (ParticleSystemSimulationSpace)0;
				EmissionModule emission = val3.emission;
				((EmissionModule)(ref emission)).rateOverTime = MinMaxCurve.op_Implicit(0f);
				((EmissionModule)(ref emission)).SetBursts((Burst[])(object)new Burst[1]
				{
					new Burst(0f, (short)Mathf.Clamp(count, 2, 30))
				});
				ShapeModule shape = val3.shape;
				((ShapeModule)(ref shape)).shapeType = (ParticleSystemShapeType)10;
				((ShapeModule)(ref shape)).radius = 0.55f;
				((ShapeModule)(ref shape)).rotation = new Vector3(-90f, 0f, 0f);
				ColorOverLifetimeModule colorOverLifetime = val3.colorOverLifetime;
				((ColorOverLifetimeModule)(ref colorOverLifetime)).enabled = true;
				Gradient val4 = new Gradient();
				val4.SetKeys((GradientColorKey[])(object)new GradientColorKey[2]
				{
					new GradientColorKey(Color.white, 0f),
					new GradientColorKey(Color.white, 1f)
				}, (GradientAlphaKey[])(object)new GradientAlphaKey[4]
				{
					new GradientAlphaKey(0f, 0f),
					new GradientAlphaKey(1f, 0.15f),
					new GradientAlphaKey(1f, 0.6f),
					new GradientAlphaKey(0f, 1f)
				});
				((ColorOverLifetimeModule)(ref colorOverLifetime)).color = MinMaxGradient.op_Implicit(val4);
				ParticleSystemRenderer component = val2.GetComponent<ParticleSystemRenderer>();
				component.renderMode = (ParticleSystemRenderMode)0;
				((Renderer)component).sharedMaterial = val;
				Light obj = val2.AddComponent<Light>();
				obj.color = color;
				obj.range = 2.5f;
				obj.intensity = 0.8f;
				Object.Destroy((Object)(object)obj, 0.4f);
				val3.Play();
				Object.Destroy((Object)(object)val2, 2f);
			}
		}

		private static Material Material()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Expected O, but got Unknown
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_mat != (Object)null)
			{
				return _mat;
			}
			Shader val = Shader.Find("Sprites/Default");
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			Texture2D val2 = new Texture2D(32, 32, (TextureFormat)4, false)
			{
				wrapMode = (TextureWrapMode)1
			};
			for (int i = 0; i < 32; i++)
			{
				for (int j = 0; j < 32; j++)
				{
					float num = ((float)j + 0.5f) / 32f - 0.5f;
					float num2 = ((float)i + 0.5f) / 32f;
					float num3 = 0f;
					if (num2 > 0.5f && num2 < 0.95f && Mathf.Abs(num) < (0.95f - num2) * 0.9f)
					{
						num3 = 1f;
					}
					else if (num2 > 0.08f && num2 <= 0.52f && Mathf.Abs(num) < 0.11f)
					{
						num3 = 1f;
					}
					val2.SetPixel(j, i, new Color(1f, 1f, 1f, num3));
				}
			}
			val2.Apply();
			_mat = new Material(val)
			{
				mainTexture = (Texture)(object)val2
			};
			return _mat;
		}
	}
}
namespace MT.Core.Vfx
{
	public static class MTBundle
	{
		private static AssetBundle _bundle;

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

		public static void Load(string pluginDir)
		{
			string text = Path.Combine(pluginDir, "Bundles", "mt_vfx");
			if (!File.Exists(text))
			{
				MTCorePlugin.Log.LogWarning((object)("No está el paquete de efectos: " + text));
				return;
			}
			_bundle = AssetBundle.LoadFromFile(text);
			if ((Object)(object)_bundle == (Object)null)
			{
				MTCorePlugin.Log.LogWarning((object)"No se pudo cargar mt_vfx");
				return;
			}
			IEnumerable<string> source = (from n in _bundle.GetAllAssetNames()
				where n.EndsWith(".mat")
				select n).Select(Path.GetFileNameWithoutExtension);
			MTCorePlugin.Log.LogInfo((object)("Paquete de efectos mt_vfx cargado. Materiales: " + string.Join(", ", source.ToArray())));
		}

		public static Material Material(string name)
		{
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Expected O, but got Unknown
			Material val = (((Object)(object)_bundle != (Object)null) ? _bundle.LoadAsset<Material>(name) : null);
			if ((Object)(object)val == (Object)null)
			{
				if (_avisados.Add(name))
				{
					MTCorePlugin.Log.LogWarning((object)(((Object)(object)_bundle == (Object)null) ? ("No se puede usar el material " + name + ": el paquete mt_vfx no está cargado") : ("No se encontró el material " + name + " en mt_vfx")));
				}
				return null;
			}
			if ((Object)(object)val.shader == (Object)null || !val.shader.isSupported)
			{
				if (_avisados.Add(name))
				{
					MTCorePlugin.Log.LogWarning((object)("El shader del material " + name + " (" + (((Object)(object)val.shader != (Object)null) ? ((Object)val.shader).name : "ninguno") + ") no funciona en este equipo"));
				}
				return null;
			}
			if (_avisados.Add(name))
			{
				MTCorePlugin.Log.LogInfo((object)("Efecto " + name + " listo (shader " + ((Object)val.shader).name + ")"));
			}
			return new Material(val);
		}
	}
	public class ToukiAura : MonoBehaviour
	{
		private const string CopyName = "MT_AuraCopia";

		private Material _aura;

		private float _check;

		private readonly Dictionary<SkinnedMeshRenderer, SkinnedMeshRenderer> _copies = new Dictionary<SkinnedMeshRenderer, SkinnedMeshRenderer>();

		private void Update()
		{
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_0270: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0287: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((((Object)(object)localPlayer != (Object)null && !((Character)localPlayer).IsDead() && CoreConfig.AuraVisible.Value) ? Manto.Factor(localPlayer) : 0f) <= 0f)
			{
				Clear();
				return;
			}
			if ((Object)(object)_aura == (Object)null)
			{
				_aura = MTBundle.Material("MT_ToukiAura");
				if ((Object)(object)_aura == (Object)null)
				{
					return;
				}
				_aura.SetFloat("_Thickness", CoreConfig.AuraGrosor.Value);
				_aura.SetFloat("_EdgePower", 2.2f);
				_aura.SetFloat("_Fill", CoreConfig.AuraRelleno.Value);
			}
			_aura.SetFloat("_Intensity", (1.2f + 0.15f * (float)ToukiRules.Level(localPlayer)) * (Manto.Active ? 1f : 0.4f));
			_check -= Time.deltaTime;
			if (_check > 0f)
			{
				return;
			}
			_check = 0.5f;
			foreach (SkinnedMeshRenderer item in (from kv in _copies
				where (Object)(object)kv.Key == (Object)null || (Object)(object)kv.Value == (Object)null
				select kv.Key).ToList())
			{
				if ((Object)(object)_copies[item] != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)_copies[item]).gameObject);
				}
				_copies.Remove(item);
			}
			SkinnedMeshRenderer[] componentsInChildren = ((Component)localPlayer).GetComponentsInChildren<SkinnedMeshRenderer>();
			foreach (SkinnedMeshRenderer val in componentsInChildren)
			{
				if (!(((Object)val).name == "MT_AuraCopia") && !((Object)(object)val.sharedMesh == (Object)null) && !_copies.ContainsKey(val))
				{
					GameObject val2 = new GameObject("MT_AuraCopia")
					{
						layer = ((Component)val).gameObject.layer
					};
					val2.transform.SetParent(((Component)val).transform.parent, false);
					val2.transform.localPosition = ((Component)val).transform.localPosition;
					val2.transform.localRotation = ((Component)val).transform.localRotation;
					val2.transform.localScale = ((Component)val).transform.localScale;
					SkinnedMeshRenderer val3 = val2.AddComponent<SkinnedMeshRenderer>();
					val3.sharedMesh = val.sharedMesh;
					val3.bones = val.bones;
					val3.rootBone = val.rootBone;
					val3.updateWhenOffscreen = true;
					((Renderer)val3).shadowCastingMode = (ShadowCastingMode)0;
					((Renderer)val3).receiveShadows = false;
					((Renderer)val3).sharedMaterials = Enumerable.Repeat<Material>(_aura, val.sharedMesh.subMeshCount).ToArray();
					_copies[val] = val3;
				}
			}
			foreach (KeyValuePair<SkinnedMeshRenderer, SkinnedMeshRenderer> copy in _copies)
			{
				((Renderer)copy.Value).enabled = ((Renderer)copy.Key).enabled && ((Component)copy.Key).gameObject.activeInHierarchy;
			}
		}

		private void Clear()
		{
			if (_copies.Count == 0)
			{
				return;
			}
			foreach (SkinnedMeshRenderer value in _copies.Values)
			{
				if ((Object)(object)value != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)value).gameObject);
				}
			}
			_copies.Clear();
		}
	}
	public class ToukiPunos : MonoBehaviour
	{
		private Material _mat;

		private GameObject _l;

		private GameObject _r;

		private Player _for;

		private void Update()
		{
			Player localPlayer = Player.m_localPlayer;
			float num = (((Object)(object)localPlayer != (Object)null && !((Character)localPlayer).IsDead() && CoreConfig.AuraPunos.Value) ? Manto.Factor(localPlayer) : 0f);
			if ((Object)(object)localPlayer != (Object)(object)_for)
			{
				Clear();
				_for = localPlayer;
			}
			if (num <= 0f)
			{
				Show(on: false);
				return;
			}
			if ((Object)(object)_mat == (Object)null)
			{
				_mat = MTBundle.Material("MT_ToukiAura");
			}
			if ((Object)(object)_mat == (Object)null)
			{
				return;
			}
			if ((Object)(object)_l == (Object)null || (Object)(object)_r == (Object)null)
			{
				VisEquipment component = ((Component)localPlayer).GetComponent<VisEquipment>();
				if ((Object)(object)component == (Object)null || (Object)(object)component.m_leftHand == (Object)null || (Object)(object)component.m_rightHand == (Object)null)
				{
					return;
				}
				Clear();
				_l = Orb(component.m_leftHand);
				_r = Orb(component.m_rightHand);
			}
			_mat.SetFloat("_Intensity", (1.2f + 0.15f * (float)ToukiRules.Level(localPlayer)) * (Manto.Active ? 1f : 0.4f));
			Show(on: true);
		}

		private GameObject Orb(Transform hand)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = GameObject.CreatePrimitive((PrimitiveType)0);
			Object.Destroy((Object)(object)obj.GetComponent<Collider>());
			((Object)obj).name = "MT_ToukiPuno";
			obj.transform.SetParent(hand, false);
			float value = CoreConfig.AuraManosTamano.Value;
			obj.transform.localScale = new Vector3(value, value, value * 1.3f);
			MeshRenderer component = obj.GetComponent<MeshRenderer>();
			((Renderer)component).sharedMaterial = _mat;
			((Renderer)component).shadowCastingMode = (ShadowCastingMode)0;
			((Renderer)component).receiveShadows = false;
			return obj;
		}

		private void Show(bool on)
		{
			if ((Object)(object)_l != (Object)null && _l.activeSelf != on)
			{
				_l.SetActive(on);
			}
			if ((Object)(object)_r != (Object)null && _r.activeSelf != on)
			{
				_r.SetActive(on);
			}
		}

		private void Clear()
		{
			if ((Object)(object)_l != (Object)null)
			{
				Object.Destroy((Object)(object)_l);
			}
			if ((Object)(object)_r != (Object)null)
			{
				Object.Destroy((Object)(object)_r);
			}
			_l = (_r = null);
		}
	}
	public class ToukiCuerpo : MonoBehaviour
	{
		private static readonly string[] Huesos = new string[16]
		{
			"Hips", "Spine", "Spine1", "Spine2", "Neck", "Head", "LeftArm", "LeftForeArm", "RightArm", "RightForeArm",
			"LeftUpLeg", "LeftLeg", "LeftFoot", "RightUpLeg", "RightLeg", "RightFoot"
		};

		private readonly List<ParticleSystem> _ps = new List<ParticleSystem>();

		private Player _for;

		private void Update()
		{
			Player localPlayer = Player.m_localPlayer;
			float num = (((Object)(object)localPlayer != (Object)null && !((Character)localPlayer).IsDead() && CoreConfig.LlamasParticulas.Value) ? Manto.Factor(localPlayer) : 0f);
			if ((Object)(object)localPlayer != (Object)(object)_for)
			{
				Clear();
				_for = localPlayer;
			}
			if (num <= 0f)
			{
				Rate(0f);
				return;
			}
			if (_ps.Count == 0)
			{
				Build(localPlayer);
			}
			int num2 = ToukiRules.Level(localPlayer);
			Rate((6f + 1.5f * (float)num2) * (Manto.Active ? 1f : 0.35f));
		}

		private void Build(Player p)
		{
			SkinnedMeshRenderer val = ((Component)p).GetComponent<VisEquipment>()?.m_bodyModel;
			if ((Object)(object)val == (Object)null || val.bones == null)
			{
				return;
			}
			Transform[] bones = val.bones;
			foreach (Transform val2 in bones)
			{
				if (!((Object)(object)val2 == (Object)null))
				{
					string n = ((Object)val2).name;
					if (Huesos.Any((string h) => n == h || n.EndsWith(":" + h) || n.EndsWith("_" + h)))
					{
						bool flag = n.Contains("Spine") || n.Contains("Hips");
						_ps.Add(ToukiManos.Flame(val2, flag ? 0.16f : 0.09f, 0.14f, 0.3f));
					}
				}
			}
			if (_ps.Count == 0)
			{
				List<Transform> list = val.bones.Where((Transform x) => (Object)(object)x != (Object)null && !((Object)x).name.ToLower().Contains("finger") && !((Object)x).name.ToLower().Contains("thumb")).ToList();
				int num = Mathf.Max(1, list.Count / 16);
				for (int num2 = 0; num2 < list.Count; num2 += num)
				{
					_ps.Add(ToukiManos.Flame(list[num2], 0.12f, 0.14f, 0.3f));
				}
				MTCorePlugin.Log.LogWarning((object)("Aura de tōki: huesos con otros nombres; uso " + _ps.Count + " de " + val.bones.Length));
			}
			else
			{
				MTCorePlugin.Log.LogInfo((object)("Aura de tōki: " + _ps.Count + " emisores en el cuerpo"));
			}
		}

		private void Rate(float r)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			foreach (ParticleSystem p in _ps)
			{
				if (!((Object)(object)p == (Object)null))
				{
					EmissionModule emission = p.emission;
					((EmissionModule)(ref emission)).rateOverTime = MinMaxCurve.op_Implicit(r);
				}
			}
		}

		private void Clear()
		{
			foreach (ParticleSystem p in _ps)
			{
				if ((Object)(object)p != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)p).gameObject);
				}
			}
			_ps.Clear();
		}
	}
	public class ToukiManos : MonoBehaviour
	{
		private ParticleSystem _left;

		private ParticleSystem _right;

		private Player _for;

		private static Texture2D _tex;

		private void Update()
		{
			Player localPlayer = Player.m_localPlayer;
			float num = (((Object)(object)localPlayer != (Object)null && !((Character)localPlayer).IsDead() && CoreConfig.LlamasParticulas.Value) ? Manto.Factor(localPlayer) : 0f);
			if ((Object)(object)localPlayer != (Object)(object)_for)
			{
				Destroy();
				_for = localPlayer;
			}
			if (num <= 0f)
			{
				Emit(0f);
				return;
			}
			if ((Object)(object)_left == (Object)null || (Object)(object)_right == (Object)null)
			{
				VisEquipment component = ((Component)localPlayer).GetComponent<VisEquipment>();
				if ((Object)(object)component == (Object)null || (Object)(object)component.m_leftHand == (Object)null || (Object)(object)component.m_rightHand == (Object)null)
				{
					return;
				}
				_left = Create(component.m_leftHand);
				_right = Create(component.m_rightHand);
			}
			int num2 = ToukiRules.Level(localPlayer);
			Emit((12f + 3f * (float)num2) * (Manto.Active ? 1f : 0.35f));
		}

		private void Emit(float rate)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			ParticleSystem[] array = (ParticleSystem[])(object)new ParticleSystem[2] { _left, _right };
			foreach (ParticleSystem val in array)
			{
				if (!((Object)(object)val == (Object)null))
				{
					EmissionModule emission = val.emission;
					((EmissionModule)(ref emission)).rateOverTime = MinMaxCurve.op_Implicit(rate);
				}
			}
		}

		private void Destroy()
		{
			if ((Object)(object)_left != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)_left).gameObject);
			}
			if ((Object)(object)_right != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)_right).gameObject);
			}
			_left = (_right = null);
		}

		private static ParticleSystem Create(Transform hand)
		{
			return Flame(hand, 0.07f, 0.08f, 0.18f);
		}

		public static ParticleSystem Flame(Transform bone, float radius, float sizeMin, float sizeMax)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Expected O, but got Unknown
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: 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_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: 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_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_0238: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Expected O, but got Unknown
			GameObject val = new GameObject("MT_ToukiMano");
			val.transform.SetParent(bone, false);
			ParticleSystem val2 = val.AddComponent<ParticleSystem>();
			val2.Stop(true, (ParticleSystemStopBehavior)0);
			MainModule main = val2.main;
			((MainModule)(ref main)).duration = 1f;
			((MainModule)(ref main)).loop = true;
			((MainModule)(ref main)).startLifetime = new MinMaxCurve(0.35f, 0.6f);
			((MainModule)(ref main)).startSpeed = new MinMaxCurve(0.1f, 0.35f);
			((MainModule)(ref main)).startSize = new MinMaxCurve(sizeMin, sizeMax);
			((MainModule)(ref main)).startColor = new MinMaxGradient(new Color(1f, 0.55f, 0.1f, 0.9f), new Color(1f, 0.85f, 0.3f, 0.8f));
			((MainModule)(ref main)).gravityModifier = MinMaxCurve.op_Implicit(-0.35f);
			((MainModule)(ref main)).simulationSpace = (ParticleSystemSimulationSpace)1;
			((MainModule)(ref main)).maxParticles = 200;
			EmissionModule emission = val2.emission;
			((EmissionModule)(ref emission)).rateOverTime = MinMaxCurve.op_Implicit(0f);
			ShapeModule shape = val2.shape;
			((ShapeModule)(ref shape)).shapeType = (ParticleSystemShapeType)0;
			((ShapeModule)(ref shape)).radius = radius;
			ColorOverLifetimeModule colorOverLifetime = val2.colorOverLifetime;
			((ColorOverLifetimeModule)(ref colorOverLifetime)).enabled = true;
			Gradient val3 = new Gradient();
			val3.SetKeys((GradientColorKey[])(object)new GradientColorKey[2]
			{
				new GradientColorKey(new Color(1f, 0.8f, 0.3f), 0f),
				new GradientColorKey(new Color(1f, 0.35f, 0.05f), 1f)
			}, (GradientAlphaKey[])(object)new GradientAlphaKey[3]
			{
				new GradientAlphaKey(0f, 0f),
				new GradientAlphaKey(0.9f, 0.15f),
				new GradientAlphaKey(0f, 1f)
			});
			((ColorOverLifetimeModule)(ref colorOverLifetime)).color = MinMaxGradient.op_Implicit(val3);
			SizeOverLifetimeModule sizeOverLifetime = val2.sizeOverLifetime;
			((SizeOverLifetimeModule)(ref sizeOverLifetime)).enabled = true;
			((SizeOverLifetimeModule)(ref sizeOverLifetime)).size = new MinMaxCurve(1f, AnimationCurve.Linear(0f, 1f, 1f, 0.3f));
			ParticleSystemRenderer component = val.GetComponent<ParticleSystemRenderer>();
			Shader val4 = Shader.Find("Legacy Shaders/Particles/Additive") ?? Shader.Find("Sprites/Default");
			((Renderer)component).material = new Material(val4)
			{
				mainTexture = (Texture)(object)Dot()
			};
			component.renderMode = (ParticleSystemRenderMode)0;
			val2.Play();
			return val2;
		}

		public static Texture2D Dot()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			//IL_002f: 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_0075: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_tex != (Object)null)
			{
				return _tex;
			}
			_tex = new Texture2D(32, 32, (TextureFormat)4, false);
			for (int i = 0; i < 32; i++)
			{
				for (int j = 0; j < 32; j++)
				{
					float num = Vector2.Distance(new Vector2((float)j, (float)i), new Vector2(15.5f, 15.5f)) / 16f;
					float num2 = Mathf.Clamp01(1f - num);
					_tex.SetPixel(j, i, new Color(1f, 1f, 1f, num2 * num2));
				}
			}
			_tex.Apply();
			return _tex;
		}
	}
}
namespace MT.Core.Touki
{
	public static class BodyLevel
	{
		public struct Breakdown
		{
			public float Combat;

			public float Movement;

			public float Dexterity;

			public float Labor;

			public float Total;
		}

		public static readonly SkillType[] MeleeWeapons;

		public static readonly SkillType[] RangedWeapons;

		public static readonly SkillType[] Work;

		public static readonly SkillType[] Physical;

		public static bool IsPhysical(SkillType skill)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return Physical.Contains(skill);
		}

		public static Breakdown Compute(Player player)
		{
			Breakdown result = new Breakdown
			{
				Combat = 0.6f * ((IEnumerable<SkillType>)MeleeWeapons).Max((Func<SkillType, float>)Lv) + 0.4f * Lv((SkillType)6),
				Movement = (Lv((SkillType)102) + Lv((SkillType)100) + Lv((SkillType)103)) / 3f,
				Dexterity = (((IEnumerable<SkillType>)RangedWeapons).Max((Func<SkillType, float>)Lv) + Lv((SkillType)101)) / 2f,
				Labor = (from x in Work.Select(Lv)
					orderby x descending
					select x).Take(2).Average()
			};
			result.Total = Mathf.Clamp(0.45f * result.Combat + 0.25f * result.Movement + 0.15f * result.Dexterity + 0.15f * result.Labor, 0f, 100f);
			return result;
			float Lv(SkillType s)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				return ((Character)player).GetSkillLevel(s);
			}
		}

		static BodyLevel()
		{
			SkillType[] array = new SkillType[7];
			RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
			MeleeWeapons = (SkillType[])(object)array;
			RangedWeapons = (SkillType[])(object)new SkillType[2]
			{
				(SkillType)8,
				(SkillType)14
			};
			SkillType[] array2 = new SkillType[3];
			RuntimeHelpers.InitializeArray(array2, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
			Work = (SkillType[])(object)array2;
			IEnumerable<SkillType> first = MeleeWeapons.Concat(RangedWeapons).Concat(Work);
			SkillType[] array3 = new SkillType[5];
			RuntimeHelpers.InitializeArray(array3, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
			Physical = first.Concat((IEnumerable<SkillType>)(object)array3).ToArray();
		}
	}
	[HarmonyPatch(typeof(Character), "Damage")]
	public static class OutgoingDamagePatch
	{
		private static void Prefix(Character __instance, HitData hit)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || hit == null || (Object)(object)__instance == (Object)(object)localPlayer || (Object)(object)hit.GetAttacker() != (Object)(object)localPlayer)
			{
				return;
			}
			int num = ToukiRules.Level(localPlayer);
			if (num <= 0)
			{
				return;
			}
			float num2 = WeaponMultiplier(hit);
			if (!(num2 <= 0f))
			{
				float num3 = SE_ToukiPasivo.Dano(num);
				float num4 = Manto.Factor(localPlayer);
				if (num4 > 0f && (!Manto.Active || Manto.Spend(localPlayer, CoreConfig.CostoGolpe.Value, isEffort: true) > 0f))
				{
					num3 += (float)num * num4 * CoreConfig.DanoPorNivel.Value;
					Manto.TrainDominio(localPlayer, 0.5f);
				}
				float num5 = 1f + num3 * num2;
				hit.m_damage.m_blunt *= num5;
				hit.m_damage.m_slash *= num5;
				hit.m_damage.m_pierce *= num5;
			}
		}

		private static float WeaponMultiplier(HitData hit)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected I4, but got Unknown
			SkillType skill = hit.m_skill;
			switch (skill - 1)
			{
			case 10:
				return CoreConfig.PunosExtra.Value;
			case 0:
			case 1:
			case 2:
			case 3:
			case 4:
			case 6:
				return 1f;
			case 7:
				return 0.8f;
			case 13:
				return 0.6f;
			default:
				return 0f;
			}
		}
	}
	[HarmonyPatch]
	public static class ObjectDamagePatch
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			Type[] array = new Type[6]
			{
				typeof(TreeBase),
				typeof(TreeLog),
				typeof(MineRock),
				typeof(MineRock5),
				typeof(Destructible),
				typeof(WearNTear)
			};
			for (int i = 0; i < array.Length; i++)
			{
				MethodInfo methodInfo = AccessTools.Method(array[i], "Damage", new Type[1] { typeof(HitData) }, (Type[])null);
				if (methodInfo != null)
				{
					yield return methodInfo;
				}
			}
		}

		private static void Prefix(HitData hit)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || hit == null || (Object)(object)hit.GetAttacker() != (Object)(object)localPlayer)
			{
				return;
			}
			int num = ToukiRules.Level(localPlayer);
			if (num > 0)
			{
				float num2 = hit.m_damage.m_blunt + hit.m_damage.m_slash + hit.m_damage.m_pierce;
				if (num2 > 0f)
				{
					float num3 = Mathf.Min(1f, CoreConfig.TalarBase.Value + (float)num * CoreConfig.TalarPorNivel.Value);
					hit.m_damage.m_chop = Mathf.Max(hit.m_damage.m_chop, num2 * num3);
					hit.m_damage.m_pickaxe = Mathf.Max(hit.m_damage.m_pickaxe, num2 * num3);
					hit.m_toolTier = (short)Mathf.Max((int)hit.m_toolTier, 1 + num / 2);
				}
				float num4 = Manto.Factor(localPlayer);
				if (!(num4 <= 0f) && (!Manto.Active || !(Manto.Spend(localPlayer, CoreConfig.CostoGolpe.Value * 0.5f, isEffort: true) <= 0f)))
				{
					float num5 = 1f + (float)num * num4 * CoreConfig.DanoObjetosPorNivel.Value;
					hit.m_damage.m_chop *= num5;
					hit.m_damage.m_pickaxe *= num5;
					hit.m_damage.m_blunt *= num5;
					hit.m_damage.m_slash *= num5;
					hit.m_damage.m_pierce *= num5;
				}
			}
		}
	}
	[HarmonyPatch(typeof(Character), "RPC_Damage")]
	public static class IncomingDamagePatch
	{
		private static void Prefix(Character __instance, HitData hit)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Invalid comparison between Unknown and I4
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Invalid comparison between Unknown and I4
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || (Object)(object)__instance != (Object)(object)localPlayer || hit == null || ((Character)localPlayer).IsDead())
			{
				return;
			}
			if (hit.GetTotalDamage() > 0f && (int)hit.m_hitType != 3)
			{
				Meditacion.Interrupt();
			}
			if (!ToukiState.IsAwakened(localPlayer))
			{
				return;
			}
			int num = ToukiRules.Level(localPlayer);
			if ((int)hit.m_hitType == 3)
			{
				AbsorbFall(localPlayer, hit);
				return;
			}
			bool flag = Vector3.Dot(((Component)localPlayer).transform.forward, hit.m_dir) > 0.3f;
			float num2 = Mathf.Clamp01(1f - (float)num * CoreConfig.DurezaPorNivel.Value);
			hit.m_damage.m_blunt *= num2;
			hit.m_damage.m_slash *= num2;
			hit.m_damage.m_pierce *= num2;
			if (flag)
			{
				((DamageTypes)(ref hit.m_damage)).Modify(Mathf.Clamp01(1f - (float)num * CoreConfig.SorpresaPorNivel.Value));
			}
			float num3 = hit.m_damage.m_blunt + hit.m_damage.m_slash + hit.m_damage.m_pierce;
			if (num3 <= 0f)
			{
				return;
			}
			float num4 = 0f;
			if (Manto.Active)
			{
				float num5 = num3 * (float)num * CoreConfig.AmortiguarPorNivel.Value;
				num4 = Manto.Spend(localPlayer, num5, isEffort: true) / Manto.CostMultiplier(localPlayer);
				if (num4 < num5)
				{
					num4 += PayFromBlue(localPlayer, num5 - num4);
				}
			}
			else if (Manto.Factor(localPlayer) > 0f)
			{
				num4 = PayFromBlue(localPlayer, num3 * (float)num * CoreConfig.AmortiguarPorNivel.Value * Manto.Factor(localPlayer));
			}
			else if (flag && Manto.TryReflex(localPlayer))
			{
				num4 = PayFromBlue(localPlayer, num3 * (float)num * CoreConfig.AmortiguarPorNivel.Value);
				((Character)localPlayer).Message((MessageType)1, Tr.Get("core_toki_reflex"), 0, (Sprite)null, false);
			}
			if (!(num4 <= 0f))
			{
				Hitos.Add(localPlayer, Hito.Maestria, num4);
				if (flag && num3 - num4 < ((Character)localPlayer).GetHealth())
				{
					Hitos.Add(localPlayer, Hito.Reflejo, 1f);
				}
				float num6 = Mathf.Clamp01((num3 - num4) / num3);
				hit.m_damage.m_blunt *= num6;
				hit.m_damage.m_slash *= num6;
				hit.m_damage.m_pierce *= num6;
				Manto.TrainDominio(localPlayer, num4 * 0.05f);
			}
		}

		private static void AbsorbFall(Player p, HitData hit)
		{
			float totalDamage = hit.GetTotalDamage();
			if (!(totalDamage <= 0f))
			{
				float num = 0f;
				if (Manto.Active)
				{
					num = Manto.Spend(p, totalDamage, isEffort: true) / Manto.CostMultiplier(p);
				}
				if (num < totalDamage)
				{
					num += PayFromBlue(p, totalDamage - num);
				}
				if (num > 0.5f)
				{
					((Character)p).Message((MessageType)1, (num >= totalDamage - 0.01f) ? Tr.Get("core_toki_cushions_fall") : Tr.Get("core_toki_cushions_part_fall"), 0, (Sprite)null, false);
				}
				if (num > 0f)
				{
					Hitos.Add(p, Hito.Maestria, num);
				}
				float num2 = Mathf.Max(0f, totalDamage - num);
				num2 *= Mathf.Clamp01(1f - (float)ToukiRules.Level(p) * CoreConfig.CaidaVidaPorNivel.Value);
				num2 = Mathf.Min(num2, Mathf.Max(0f, ((Character)p).GetHealth() - CoreConfig.CaidaVidaMinima.Value));
				if (num2 < totalDamage - num - 0.01f && num2 < ((Character)p).GetHealth())
				{
					Hitos.Add(p, Hito.Reflejo, 1f);
				}
				((DamageTypes)(ref hit.m_damage)).Modify(Mathf.Clamp01(num2 / totalDamage));
			}
		}

		private static float PayFromBlue(Player p, float damage)
		{
			float num = Manto.CostMultiplier(p);
			float num2 = Mathf.Min(damage * num, p.GetEitr() - 1f);
			if (num2 <= 0f)
			{
				return 0f;
			}
			((Character)p).UseEitr(num2);
			return num2 / num;
		}
	}
	[HarmonyPatch(typeof(Character), "ApplyDamage")]
	public static class GolpeMortalPatch
	{
		private static float _last = -9999f;

		private static void Prefix(Character __instance, HitData hit)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Invalid comparison between Unknown and I4
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || (Object)(object)__instance != (Object)(object)localPlayer || hit == null || ((Character)localPlayer).IsDead() || !ToukiState.IsAwakened(localPlayer) || (int)hit.m_hitType == 3)
			{
				return;
			}
			int num = ToukiRules.Level(localPlayer);
			float num2 = (Manto.Active ? CoreConfig.SalvarGolpeMortal.Value : ((CoreConfig.SalvarSinManto.Value > 0f) ? Mathf.Max(30f, CoreConfig.SalvarSinManto.Value - 10f * (float)num) : 0f));
			if (num2 <= 0f)
			{
				return;
			}
			float totalDamage = hit.GetTotalDamage();
			float value = CoreConfig.CaidaVidaMinima.Value;
			if (!(totalDamage < ((Character)localPlayer).GetHealth()) && !(Time.time - _last < num2) && !(((Character)localPlayer).GetHealth() <= value))
			{
				_last = Time.time;
				((DamageTypes)(ref hit.m_damage)).Modify(Mathf.Clamp01((((Character)localPlayer).GetHealth() - value) / totalDamage));
				if (Manto.Active)
				{
					Manto.Spend(localPlayer, Manto.Charge / Manto.CostMultiplier(localPlayer) + 1f, isEffort: true);
				}
				((Character)localPlayer).Message((MessageType)2, Tr.Get("core_toki_withstands_deadly_blow"), 0, (Sprite)null, false);
			}
		}
	}
	[HarmonyPatch(typeof(Skills), "OnDeath")]
	public static class DeathPatch
	{
		private static SkillType[] Tracked => (SkillType[])(object)new SkillType[5]
		{
			(SkillType)(int)MTSkills.Reserva,
			(SkillType)(int)MTSkills.Control,
			(SkillType)(int)MTSkills.Dominio,
			(SkillType)(int)MTSkills.Meditacion,
			(SkillType)(int)MTSkills.Aguante
		};

		private static void Prefix(Skills __instance, out float[] __state)
		{
			__state = null;
			if (CoreConfig.Muerte.Value != CoreConfig.ModoMuerte.Clasico)
			{
				SkillType[] tracked = Tracked;
				__state = new float[tracked.Length];
				for (int i = 0; i < tracked.Length; i++)
				{
					__state[i] = GetSkill(__instance, tracked[i]).m_level;
				}
			}
		}

		private static void Postfix(Skills __instance, float[] __state)
		{
			if (__state == null)
			{
				return;
			}
			float num = ((CoreConfig.Muerte.Value == CoreConfig.ModoMuerte.Protegido) ? 1f : 0.5f);
			SkillType[] tracked = Tracked;
			for (int i = 0; i < tracked.Length; i++)
			{
				Skill skill = GetSkill(__instance, tracked[i]);
				float num2 = __state[i] - skill.m_level;
				if (num2 > 0f)
				{
					skill.m_level += num2 * num;
				}
			}
		}

		private static Skill GetSkill(Skills skills, SkillType type)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			return Traverse.Create((object)skills).Method("GetSkill", new object[1] { type }).GetValue<Skill>();
		}
	}
	public static class Entrenamiento
	{
		private const string TrainedKey = "MT.Core.StaminaEntrenada";

		private const string DayKey = "MT.Core.EntrenoDia";

		private const string CarryKey = "MT.Core.CargaEntrenada";

		public static float StaminaEntrenada(Player p)
		{
			if (!p.m_customData.TryGetValue("MT.Core.StaminaEntrenada", out var value) || !float.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
			{
				return 0f;
			}
			return result;
		}

		public static float ProgresoEsfuerzo(Player p)
		{
			return ProgresoFisico.Read(p, "Esfuerzo");
		}

		public static float CargaEntrenada(Player p)
		{
			if (!p.m_customData.TryGetValue("MT.Core.CargaEntrenada", out var value) || !float.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
			{
				return 0f;
			}
			return result;
		}

		public static void Entrenar(Player p, float effort)
		{
			i