Decompiled source of ElementalOverhaul v0.9.1

ElementalOverhaul.dll

Decompiled a week ago
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.Rendering;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("ElementalOverhaul")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+c8d916938c26399a875fb85214b0a09245484915")]
[assembly: AssemblyProduct("ElementalOverhaul")]
[assembly: AssemblyTitle("ElementalOverhaul")]
[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 ElementalOverhaul
{
	public class ElementalBody : MonoBehaviour
	{
		private struct Emitter
		{
			public ParticleSystem ps;

			public ConfigEntry<float> density;
		}

		public static readonly HashSet<ElementalBody> All = new HashSet<ElementalBody>();

		public static readonly Dictionary<string, Material> Mats = new Dictionary<string, Material>();

		public static readonly Dictionary<string, GameObject> Sources = new Dictionary<string, GameObject>();

		private static readonly Dictionary<Mesh, float> areas = new Dictionary<Mesh, float>();

		private static readonly Color[] LightCol = (Color[])(object)new Color[5]
		{
			new Color(1f, 0.6f, 0.28f),
			new Color(0.6f, 0.8f, 1f),
			new Color(0.5f, 0.9f, 0.2f),
			new Color(0.4f, 0.78f, 1f),
			new Color(0.5f, 1f, 0.65f)
		};

		private static readonly float[] LightInt = new float[5] { 2f, 0.5f, 0.4f, 1.2f, 1.2f };

		public readonly float[] Level = new float[5];

		public readonly float[] Age = new float[5];

		public SkinnedMeshRenderer[] Renderers;

		private Character ch;

		private SkinnedMeshRenderer body;

		private float area;

		private float height;

		private float radius;

		private readonly List<Emitter>[] emitters = new List<Emitter>[5];

		private Light glow;

		private static readonly int[,] Pairs = new int[10, 2]
		{
			{ 0, 1 },
			{ 0, 3 },
			{ 0, 2 },
			{ 0, 4 },
			{ 1, 3 },
			{ 1, 2 },
			{ 1, 4 },
			{ 3, 2 },
			{ 3, 4 },
			{ 2, 4 }
		};

		public float PatternScale => 1f / Mathf.Sqrt(Mathf.Max(height, 0.5f) / 1.8f);

		private void Awake()
		{
			//IL_0052: 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_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Expected O, but got Unknown
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			ch = ((Component)this).GetComponent<Character>();
			Renderers = ((Component)this).GetComponentsInChildren<SkinnedMeshRenderer>();
			body = Plugin.Body(ch);
			radius = ch.GetRadius();
			Collider component = ((Component)this).GetComponent<Collider>();
			float num;
			if (!Object.op_Implicit((Object)(object)component))
			{
				num = 2f;
			}
			else
			{
				Bounds bounds = component.bounds;
				num = ((Bounds)(ref bounds)).size.y;
			}
			height = num;
			area = Mathf.Min(Object.op_Implicit((Object)(object)body) ? Area(body) : ((float)Math.PI * 2f * radius * height), 14f);
			GameObject val = new GameObject("QE_light");
			val.transform.SetParent(((Component)this).transform, false);
			val.transform.position = ((Component)this).transform.position + Vector3.up * height * 0.6f;
			glow = val.AddComponent<Light>();
			glow.type = (LightType)2;
			glow.shadows = (LightShadows)0;
			glow.range = Mathf.Max(4f, height * 2.2f);
			All.Add(this);
		}

		private void OnDestroy()
		{
			All.Remove(this);
		}

		private void Release()
		{
			if (Object.op_Implicit((Object)(object)glow))
			{
				Object.Destroy((Object)(object)((Component)glow).gameObject);
			}
			List<Emitter>[] array = emitters;
			foreach (List<Emitter> list in array)
			{
				if (list == null)
				{
					continue;
				}
				foreach (Emitter item in list)
				{
					if (Object.op_Implicit((Object)(object)item.ps))
					{
						((Component)item.ps).transform.SetParent((Transform)null, true);
						item.ps.Stop(true, (ParticleSystemStopBehavior)1);
						Object.Destroy((Object)(object)((Component)item.ps).gameObject, 2.5f);
					}
				}
			}
		}

		private void Update()
		{
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0317: Unknown result type (might be due to invalid IL or missing references)
			//IL_031b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0310: Unknown result type (might be due to invalid IL or missing references)
			//IL_033a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0344: Unknown result type (might be due to invalid IL or missing references)
			//IL_034b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0368: Unknown result type (might be due to invalid IL or missing references)
			//IL_036f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0376: Unknown result type (might be due to invalid IL or missing references)
			SEMan sEMan = ch.GetSEMan();
			float deltaTime = Time.deltaTime;
			bool flag = false;
			int num = 0;
			for (int i = 0; i < 5; i++)
			{
				bool flag2 = sEMan.HaveStatusEffect(Overlay.Hashes[i]) || Plugin.Forced(i);
				Level[i] = Mathf.MoveTowards(Level[i], flag2 ? 1f : 0f, deltaTime * (flag2 ? 6f : 1.5f));
				Age[i] = (flag2 ? (Age[i] + deltaTime) : ((Level[i] > 0f) ? Age[i] : 0f));
				flag |= Level[i] > 0f;
				if (flag2)
				{
					num++;
				}
			}
			if (!flag)
			{
				Release();
				Object.Destroy((Object)(object)this);
				return;
			}
			float num2 = 1f / Mathf.Sqrt((float)Mathf.Max(num, 1));
			ComboPick(Level, out var id, out var w, out var allW);
			Color val = Color.black;
			float num3 = 0f;
			float num4 = 0f;
			for (int j = 0; j < 5; j++)
			{
				if (Level[j] > 0f && emitters[j] == null)
				{
					emitters[j] = Build(j);
				}
				if (emitters[j] != null)
				{
					foreach (Emitter item in emitters[j])
					{
						EmissionModule emission = item.ps.emission;
						((EmissionModule)(ref emission)).rateOverTimeMultiplier = item.density.Value * P.GlobalParticleDensity.Value * area * num2 * Level[j] * Keep(id, w, allW, j);
					}
				}
				val += LightCol[j] * LightInt[j] * Level[j];
				num3 += LightInt[j] * Level[j];
				if (Level[j] > 0f)
				{
					num4 = Mathf.Max(num4, LightInt[j] * Level[j]);
				}
			}
			float timeSinceLevelLoad = Time.timeSinceLevelLoad;
			float num5 = 0.82f + 0.18f * (Mathf.Sin(timeSinceLevelLoad * 9.1f + 1.7f) * 0.5f + Mathf.Sin(timeSinceLevelLoad * 23.7f + 3.4f) * 0.5f);
			if (Level[3] > 0f)
			{
				num5 *= Mathf.Lerp(1f, Mathf.Max(0f, 1f + P.LightningLightFlash.Value * (1.6f * Burst(timeSinceLevelLoad) - 0.4f)), Level[3]);
			}
			glow.color = ((num3 > 0f) ? (val / num3) : Color.black);
			if (allW > 0f)
			{
				glow.color = Color.Lerp(glow.color, P.CombosAllColor.Value, allW);
			}
			else if (id > 0)
			{
				glow.color = Color.Lerp(glow.color, ComboColor(id), w);
			}
			glow.intensity = num4 * Plugin.LightMultiplier * 2f * num5;
		}

		private static bool ComboOn(int id)
		{
			return id switch
			{
				1 => P.CombosSteamEnabled.Value, 
				2 => P.CombosOverloadEnabled.Value, 
				3 => P.CombosToxicBurnEnabled.Value, 
				4 => P.CombosGhostFireEnabled.Value, 
				5 => P.CombosConductiveIceEnabled.Value, 
				6 => P.CombosFrozenVeinsEnabled.Value, 
				7 => P.CombosWraithChillEnabled.Value, 
				8 => P.CombosCorrosiveSparksEnabled.Value, 
				9 => P.CombosSoulLightningEnabled.Value, 
				_ => P.CombosBlightEnabled.Value, 
			};
		}

		private static Color ComboColor(int id)
		{
			//IL_0033: 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_0049: 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)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: 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)
			//IL_0080: 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_0096: Unknown result type (might be due to invalid IL or missing references)
			return (Color)(id switch
			{
				1 => P.CombosSteamColor.Value, 
				2 => P.CombosOverloadColor.Value, 
				3 => P.CombosToxicBurnColor.Value, 
				4 => P.CombosGhostFireColor.Value, 
				5 => P.CombosConductiveIceColor.Value, 
				6 => P.CombosFrozenVeinsColor.Value, 
				7 => P.CombosWraithChillColor.Value, 
				8 => P.CombosCorrosiveSparksColor.Value, 
				9 => P.CombosSoulLightningColor.Value, 
				_ => P.CombosBlightColor.Value, 
			});
		}

		private static void ComboPick(float[] lv, out int id, out float w, out float allW)
		{
			id = 0;
			w = 0f;
			float num = (P.CombosEnabled.Value ? 1f : 0f);
			allW = Mathf.Min(Mathf.Min(Mathf.Min(lv[0], lv[1]), Mathf.Min(lv[2], lv[3])), lv[4]) * (P.CombosAllEnabled.Value ? num : 0f);
			if (allW > 0.001f)
			{
				return;
			}
			for (int i = 0; i < 10; i++)
			{
				float num2 = Mathf.Min(lv[Pairs[i, 0]], lv[Pairs[i, 1]]) * (ComboOn(i + 1) ? num : 0f);
				if (num2 > w + 0.001f)
				{
					w = num2;
					id = i + 1;
				}
			}
		}

		private static float Keep(int id, float w, float allW, int slot)
		{
			bool flag = id > 0 && (Pairs[id - 1, 0] == slot || Pairs[id - 1, 1] == slot);
			return 1f - P.CombosReplace.Value * Mathf.Max(allW, flag ? w : 0f);
		}

		private static float Frac(float x)
		{
			return x - Mathf.Floor(x);
		}

		private static float H3(float x, float y, float z)
		{
			x = Frac(x * 0.3183099f + 0.1f) * 17f;
			y = Frac(y * 0.3183099f + 0.1f) * 17f;
			z = Frac(z * 0.3183099f + 0.1f) * 17f;
			return Frac(x * y * z * (x + y + z));
		}

		private static float Burst(float t)
		{
			return ((H3(Mathf.Floor(t * P.LightningBurstRate.Value), 1.3f, 2.1f) >= 1f - P.LightningBurstChance.Value) ? 1f : 0f) * ((H3(Mathf.Floor(t * P.LightningFlickerRate.Value), 0.37f, 0.71f) >= 0.25f) ? 1f : 0f);
		}

		private static float Area(SkinnedMeshRenderer r)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: 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_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: 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)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: 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_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: 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)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: 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)
			Mesh sharedMesh = r.sharedMesh;
			if (!areas.TryGetValue(sharedMesh, out var value))
			{
				Vector3[] vertices = sharedMesh.vertices;
				int[] triangles = sharedMesh.triangles;
				Vector3 lossyScale = ((Component)r).transform.lossyScale;
				for (int i = 0; i < triangles.Length; i += 3)
				{
					Vector3 val = Vector3.Scale(vertices[triangles[i]], lossyScale);
					float num = value;
					Vector3 val2 = Vector3.Cross(Vector3.Scale(vertices[triangles[i + 1]], lossyScale) - val, Vector3.Scale(vertices[triangles[i + 2]], lossyScale) - val);
					value = num + ((Vector3)(ref val2)).magnitude * 0.5f;
				}
				areas[sharedMesh] = value;
			}
			return value;
		}

		private List<Emitter> Build(int slot)
		{
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			List<Emitter> list = new List<Emitter>();
			switch (slot)
			{
			case 0:
				list.Add(Clone("tongues", P.FireTongueDensity, "vfx_Burning/flames (1)", delegate(ParticleSystem ps)
				{
					Size(ps, P.FireTongueSize.Value);
					Vel(ps, 0.08f, P.FireTongueRise.Value * 0.65f, P.FireTongueRise.Value * 1.3f);
				}));
				list.Add(Make("embers", P.FireEmberDensity, Mat("vfx_Burning/sparcs (1)"), delegate(ParticleSystem ps)
				{
					//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_0013: 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_0048: 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_0082: Unknown result type (might be due to invalid IL or missing references)
					//IL_009f: 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)
					//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
					MainModule main = ps.main;
					((MainModule)(ref main)).startLifetime = new MinMaxCurve(1f, 2f);
					Size(ps, P.FireEmberSize.Value);
					((MainModule)(ref main)).startColor = new MinMaxGradient(new Color(1f, 0.77f, 0f), Color.white);
					Vel(ps, 0f, 0.6f, 1.3f);
					Noise(ps, 0.6f, 1.2f, 0.1f);
					ColorOverLifetimeModule colorOverLifetime = ps.colorOverLifetime;
					((ColorOverLifetimeModule)(ref colorOverLifetime)).enabled = true;
					((ColorOverLifetimeModule)(ref colorOverLifetime)).color = Grad(0f, 1f, 0.9f, 0.5f, 0f, 0.1f, 1f, 0.8f, 0.4f, 1f, 1f, 1f, 0.3f, 0.05f, 0f);
					SizeOverLifetimeModule sizeOverLifetime = ps.sizeOverLifetime;
					((SizeOverLifetimeModule)(ref sizeOverLifetime)).enabled = true;
					((SizeOverLifetimeModule)(ref sizeOverLifetime)).size = Curve(0f, 1f, 1f, 0f);
				}));
				break;
			case 1:
				list.Add(Make("flakes", P.FrostFlakeDensity, Tinted("vfx_Frost/vfx_BloodHit 1", new Color(1.2f, 1.2f, 1.2f, 1f)), delegate(ParticleSystem ps)
				{
					//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_0013: 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_005c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0061: Unknown result type (might be due to invalid IL or missing references)
					//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
					//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
					//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
					MainModule main = ps.main;
					((MainModule)(ref main)).startLifetime = new MinMaxCurve(1.2f, 2.2f);
					Size(ps, P.FrostFlakeSize.Value);
					((MainModule)(ref main)).startColor = new MinMaxGradient(new Color(0.85f, 0.93f, 1f, 0.9f), new Color(1f, 1f, 1f, 0.9f));
					Vel(ps, 0.05f, (0f - P.FrostFlakeFall.Value) * 1.4f, (0f - P.FrostFlakeFall.Value) * 0.6f);
					Noise(ps, 0.2f, 2f, 0.05f);
					ColorOverLifetimeModule colorOverLifetime = ps.colorOverLifetime;
					((ColorOverLifetimeModule)(ref colorOverLifetime)).enabled = true;
					((ColorOverLifetimeModule)(ref colorOverLifetime)).color = Grad(0f, 1f, 1f, 1f, 0f, 0.15f, 1f, 1f, 1f, 1f, 0.8f, 1f, 1f, 1f, 1f, 1f, 1f, 1f, 1f, 0f);
				}));
				break;
			case 2:
				list.Add(Make("drips", P.PoisonDripDensity, Tinted("vfx_Frost/vfx_BloodHit 1", Color.white), delegate(ParticleSystem ps)
				{
					//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_0013: 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_005c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0061: Unknown result type (might be due to invalid IL or missing references)
					//IL_0072: 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_0082: Unknown result type (might be due to invalid IL or missing references)
					//IL_009f: Unknown result type (might be due to invalid IL or missing references)
					MainModule main = ps.main;
					((MainModule)(ref main)).startLifetime = new MinMaxCurve(0.6f, 0.95f);
					Size(ps, P.PoisonDripSize.Value);
					((MainModule)(ref main)).startColor = new MinMaxGradient(new Color(0.42f, 0.8f, 0.08f, 0.95f), new Color(0.55f, 0.9f, 0.15f, 0.95f));
					((MainModule)(ref main)).gravityModifier = MinMaxCurve.op_Implicit(0.55f);
					ColorOverLifetimeModule colorOverLifetime = ps.colorOverLifetime;
					((ColorOverLifetimeModule)(ref colorOverLifetime)).enabled = true;
					((ColorOverLifetimeModule)(ref colorOverLifetime)).color = Grad(0f, 1f, 1f, 1f, 0f, 0.1f, 1f, 1f, 1f, 1f, 0.85f, 1f, 1f, 1f, 1f, 1f, 1f, 1f, 1f, 0f);
					ParticleSystemRenderer component = ((Component)ps).GetComponent<ParticleSystemRenderer>();
					component.renderMode = (ParticleSystemRenderMode)1;
					component.lengthScale = 2.4f;
				}));
				break;
			case 3:
				list.Add(Make("sparks", P.LightningSparkDensity, Mat("fx_Lightning/Sparcs"), delegate(ParticleSystem ps)
				{
					//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_0013: 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)
					MainModule main = ps.main;
					((MainModule)(ref main)).startLifetime = new MinMaxCurve(0.06f, 0.12f);
					Size(ps, P.LightningSparkSize.Value);
					((MainModule)(ref main)).startRotation = new MinMaxCurve(0f, 6.28f);
				}));
				break;
			case 4:
				list.Add(Make("wisps", P.SpiritWispDensity, Mat("vfx_UndeadBurn/trails"), delegate(ParticleSystem ps)
				{
					//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_0013: 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_004d: 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)
					//IL_009d: Unknown result type (might be due to invalid IL or missing references)
					//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
					//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
					//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
					//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
					//IL_00df: Unknown result type (might be due to invalid IL or missing references)
					//IL_0101: 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)
					MainModule main = ps.main;
					((MainModule)(ref main)).startLifetime = new MinMaxCurve(1f, 2f);
					Size(ps, 0.02f);
					((MainModule)(ref main)).startColor = new MinMaxGradient(new Color(0.01f, 0.78f, 0.65f), new Color(0.17f, 0.88f, 0.79f));
					Vel(ps, 0f, P.SpiritWispRise.Value * 0.6f, P.SpiritWispRise.Value * 1.4f);
					Noise(ps, 0.5f, 1f, 0.1f);
					ColorOverLifetimeModule colorOverLifetime = ps.colorOverLifetime;
					((ColorOverLifetimeModule)(ref colorOverLifetime)).enabled = true;
					((ColorOverLifetimeModule)(ref colorOverLifetime)).color = Grad(0f, 1f, 0.9f, 0.5f, 0f, 0.1f, 1f, 0.85f, 0.47f, 1f, 1f, 0.9f, 0.3f, 0.3f, 0f);
					TrailModule trails = ps.trails;
					((TrailModule)(ref trails)).enabled = true;
					((TrailModule)(ref trails)).lifetime = MinMaxCurve.op_Implicit(0.35f);
					((TrailModule)(ref trails)).widthOverTrail = Curve(0f, 1f, 1f, 0f);
					((TrailModule)(ref trails)).colorOverTrail = Grad(0f, 1f, 1f, 1f, 1f, 1f, 1f, 1f, 1f, 0f);
					ParticleSystemRenderer component = ((Component)ps).GetComponent<ParticleSystemRenderer>();
					component.renderMode = (ParticleSystemRenderMode)5;
					component.trailMaterial = Mat("vfx_UndeadBurn/trails#trail");
				}));
				break;
			}
			list.RemoveAll((Emitter e) => !Object.op_Implicit((Object)(object)e.ps));
			return list;
		}

		private Emitter Clone(string name, ConfigEntry<float> density, string key, Action<ParticleSystem> setup)
		{
			//IL_004e: 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_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: 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_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			if (!Sources.TryGetValue(key, out var value) || !Object.op_Implicit((Object)(object)value))
			{
				return default(Emitter);
			}
			GameObject val = Object.Instantiate<GameObject>(value, ((Component)this).transform, false);
			((Object)val).name = "QE_" + name;
			val.SetActive(true);
			val.transform.localPosition = Vector3.zero;
			val.transform.localRotation = Quaternion.identity;
			val.transform.localScale = Vector3.one;
			foreach (Transform item in val.transform)
			{
				Object.Destroy((Object)(object)((Component)item).gameObject);
			}
			ParticleSystem component = val.GetComponent<ParticleSystem>();
			component.Stop(true, (ParticleSystemStopBehavior)0);
			MainModule main = component.main;
			((MainModule)(ref main)).loop = true;
			((MainModule)(ref main)).playOnAwake = false;
			((MainModule)(ref main)).simulationSpace = (ParticleSystemSimulationSpace)1;
			((MainModule)(ref main)).scalingMode = (ParticleSystemScalingMode)2;
			((MainModule)(ref main)).maxParticles = 200;
			EmissionModule emission = component.emission;
			((EmissionModule)(ref emission)).rateOverTime = MinMaxCurve.op_Implicit(0f);
			((EmissionModule)(ref emission)).SetBursts((Burst[])(object)new Burst[0]);
			LightsModule lights = component.lights;
			((LightsModule)(ref lights)).enabled = false;
			SubEmittersModule subEmitters = component.subEmitters;
			((SubEmittersModule)(ref subEmitters)).enabled = false;
			Shape(component);
			setup(component);
			component.Play();
			return new Emitter
			{
				ps = component,
				density = density
			};
		}

		private void Shape(ParticleSystem ps)
		{
			//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_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: 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_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			ShapeModule shape = ps.shape;
			((ShapeModule)(ref shape)).enabled = true;
			((ShapeModule)(ref shape)).position = Vector3.zero;
			((ShapeModule)(ref shape)).rotation = Vector3.zero;
			((ShapeModule)(ref shape)).scale = Vector3.one;
			if (Object.op_Implicit((Object)(object)body))
			{
				((ShapeModule)(ref shape)).shapeType = (ParticleSystemShapeType)14;
				((ShapeModule)(ref shape)).skinnedMeshRenderer = body;
				((ShapeModule)(ref shape)).meshShapeType = (ParticleSystemMeshShapeType)2;
			}
			else
			{
				((ShapeModule)(ref shape)).shapeType = (ParticleSystemShapeType)0;
				((ShapeModule)(ref shape)).radius = radius;
				((Component)ps).transform.position = ((Component)this).transform.position + Vector3.up * height * 0.5f;
			}
		}

		private Emitter Make(string name, ConfigEntry<float> density, Material mat, Action<ParticleSystem> setup)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: 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_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: 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_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)mat))
			{
				return default(Emitter);
			}
			GameObject val = new GameObject("QE_" + name);
			val.transform.SetParent(((Component)this).transform, false);
			ParticleSystem val2 = val.AddComponent<ParticleSystem>();
			val2.Stop(true, (ParticleSystemStopBehavior)0);
			MainModule main = val2.main;
			((MainModule)(ref main)).loop = true;
			((MainModule)(ref main)).playOnAwake = false;
			((MainModule)(ref main)).simulationSpace = (ParticleSystemSimulationSpace)1;
			((MainModule)(ref main)).scalingMode = (ParticleSystemScalingMode)2;
			((MainModule)(ref main)).startSpeed = MinMaxCurve.op_Implicit(0f);
			((MainModule)(ref main)).maxParticles = 200;
			EmissionModule emission = val2.emission;
			((EmissionModule)(ref emission)).rateOverTime = MinMaxCurve.op_Implicit(0f);
			ShapeModule shape = val2.shape;
			((ShapeModule)(ref shape)).enabled = true;
			if (Object.op_Implicit((Object)(object)body))
			{
				((ShapeModule)(ref shape)).shapeType = (ParticleSystemShapeType)14;
				((ShapeModule)(ref shape)).skinnedMeshRenderer = body;
				((ShapeModule)(ref shape)).meshShapeType = (ParticleSystemMeshShapeType)2;
			}
			else
			{
				((ShapeModule)(ref shape)).shapeType = (ParticleSystemShapeType)0;
				((ShapeModule)(ref shape)).radius = radius;
				val.transform.position = ((Component)this).transform.position + Vector3.up * height * 0.5f;
			}
			ParticleSystemRenderer component = val.GetComponent<ParticleSystemRenderer>();
			((Renderer)component).sharedMaterial = mat;
			component.renderMode = (ParticleSystemRenderMode)0;
			((Renderer)component).shadowCastingMode = (ShadowCastingMode)0;
			((Renderer)component).receiveShadows = false;
			setup(val2);
			val2.Play();
			return new Emitter
			{
				ps = val2,
				density = density
			};
		}

		private static Material Mat(string key)
		{
			if (!Mats.TryGetValue(key, out var value))
			{
				return null;
			}
			return value;
		}

		private unsafe static Material Tinted(string key, Color c)
		{
			//IL_0017: 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_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			Material val = Mat(key);
			if (!Object.op_Implicit((Object)(object)val))
			{
				return null;
			}
			Color val2 = c;
			string key2 = key + "#" + ((object)(*(Color*)(&val2))/*cast due to .constrained prefix*/).ToString();
			if (!Mats.TryGetValue(key2, out var value))
			{
				value = new Material(val);
				value.SetColor("_Color", c);
				Mats[key2] = value;
			}
			return value;
		}

		private static void Size(ParticleSystem ps, float size)
		{
			//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_0024: Unknown result type (might be due to invalid IL or missing references)
			MainModule main = ps.main;
			float num = size * P.GlobalParticleSize.Value;
			((MainModule)(ref main)).startSize = new MinMaxCurve(num * 0.7f, num * 1.3f);
		}

		private static void Vel(ParticleSystem ps, float xz, float yMin, float yMax)
		{
			//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_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: 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)
			VelocityOverLifetimeModule velocityOverLifetime = ps.velocityOverLifetime;
			((VelocityOverLifetimeModule)(ref velocityOverLifetime)).enabled = true;
			((VelocityOverLifetimeModule)(ref velocityOverLifetime)).space = (ParticleSystemSimulationSpace)1;
			((VelocityOverLifetimeModule)(ref velocityOverLifetime)).x = new MinMaxCurve(0f - xz, xz);
			((VelocityOverLifetimeModule)(ref velocityOverLifetime)).y = new MinMaxCurve(yMin, yMax);
			((VelocityOverLifetimeModule)(ref velocityOverLifetime)).z = new MinMaxCurve(0f - xz, xz);
		}

		private static void Noise(ParticleSystem ps, float strength, float frequency, float scroll)
		{
			//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_0012: 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)
			NoiseModule noise = ps.noise;
			((NoiseModule)(ref noise)).enabled = true;
			((NoiseModule)(ref noise)).strength = MinMaxCurve.op_Implicit(strength);
			((NoiseModule)(ref noise)).frequency = frequency;
			((NoiseModule)(ref noise)).scrollSpeed = MinMaxCurve.op_Implicit(scroll);
		}

		private static MinMaxGradient Grad(params float[] k)
		{
			//IL_002f: 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_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Expected O, but got Unknown
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			int num = k.Length / 5;
			GradientColorKey[] array = (GradientColorKey[])(object)new GradientColorKey[num];
			GradientAlphaKey[] array2 = (GradientAlphaKey[])(object)new GradientAlphaKey[num];
			for (int i = 0; i < num; i++)
			{
				array[i] = new GradientColorKey(new Color(k[i * 5 + 1], k[i * 5 + 2], k[i * 5 + 3]), k[i * 5]);
				array2[i] = new GradientAlphaKey(k[i * 5 + 4], k[i * 5]);
			}
			Gradient val = new Gradient();
			val.SetKeys(array, array2);
			return new MinMaxGradient(val);
		}

		private static MinMaxCurve Curve(params float[] k)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			AnimationCurve val = new AnimationCurve();
			for (int i = 0; i < k.Length; i += 2)
			{
				val.AddKey(k[i], k[i + 1]);
			}
			return new MinMaxCurve(1f, val);
		}
	}
	public class Overlay : MonoBehaviour
	{
		public static readonly int[] Hashes = new int[5]
		{
			SEMan.s_statusEffectBurning,
			SEMan.s_statusEffectFrost,
			SEMan.s_statusEffectPoison,
			SEMan.s_statusEffectLightning,
			SEMan.s_statusEffectSpirit
		};

		private static readonly int ElemA = Shader.PropertyToID("_ElemA");

		private static readonly int ElemB = Shader.PropertyToID("_ElemB");

		private static readonly int Age = Shader.PropertyToID("_ElemAge");

		private static readonly int SunDir = Shader.PropertyToID("_ElemSunDir");

		private static readonly int SceneLight = Shader.PropertyToID("_ElemLight");

		private static readonly int Scale = Shader.PropertyToID("_ElemScale");

		private static readonly int ShellH = Shader.PropertyToID("_ShellH");

		private static readonly int Mask = Shader.PropertyToID("_ElemMask");

		private static readonly int Cutoff = Shader.PropertyToID("_ElemCutoff");

		private static ConfigEntry<bool> on;

		private static ConfigEntry<float> range;

		private static string dir;

		private Material mat;

		private CommandBuffer cb;

		private Camera cam;

		public static int Slot(int nameHash)
		{
			return Array.IndexOf(Hashes, nameHash);
		}

		public static void Bind(ConfigFile config, string pluginDir)
		{
			dir = pluginDir;
			on = config.Bind<bool>("Overlay", "Enabled", true, "Draw the elemental surface shader on affected creatures (needs the elementaloverlay bundle)");
			range = config.Bind<float>("Overlay", "MaxDistance", 50f, "Skip creatures farther than this from the camera, in metres");
		}

		private void Start()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Invalid comparison between Unknown and I4
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Expected O, but got Unknown
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Expected O, but got Unknown
			string text = (((int)Application.platform == 2) ? "elementaloverlay_windows" : (((int)Application.platform == 13) ? "elementaloverlay_linux" : null));
			if (text == null)
			{
				Debug.LogWarning((object)("[ElementalOverhaul] no overlay shader for " + ((object)Application.platform/*cast due to .constrained prefix*/).ToString() + "; particles and light only"));
				return;
			}
			string text2 = Path.Combine(dir, text);
			if (File.Exists(text2))
			{
				AssetBundle val = AssetBundle.LoadFromFile(text2);
				Shader val2 = (Object.op_Implicit((Object)(object)val) ? val.LoadAllAssets<Shader>().FirstOrDefault() : null);
				if (!Object.op_Implicit((Object)(object)val2) || !val2.isSupported)
				{
					Debug.LogWarning((object)("[ElementalOverhaul] overlay shader missing or unsupported in " + text2));
					return;
				}
				mat = new Material(val2);
				cb = new CommandBuffer
				{
					name = "ElementalOverlay"
				};
				Debug.Log((object)"[ElementalOverhaul] overlay shader loaded");
			}
		}

		private void LateUpdate()
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: 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_0266: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b0: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.Overhaul)
			{
				return;
			}
			Camera val = (Object.op_Implicit((Object)(object)GameCamera.instance) ? Traverse.Create((object)GameCamera.instance).Field<Camera>("m_camera").Value : Camera.main);
			float num = range.Value * range.Value;
			Vector3 val2;
			if (Object.op_Implicit((Object)(object)val))
			{
				foreach (Character allCharacter in Character.GetAllCharacters())
				{
					if (Object.op_Implicit((Object)(object)allCharacter))
					{
						val2 = ((Component)allCharacter).transform.position - ((Component)val).transform.position;
						if (((Vector3)(ref val2)).sqrMagnitude <= num && !Object.op_Implicit((Object)(object)((Component)allCharacter).GetComponent<ElementalBody>()) && (Plugin.AnyForced || ((IEnumerable<int>)Hashes).Any((Func<int, bool>)allCharacter.GetSEMan().HaveStatusEffect)))
						{
							((Component)allCharacter).gameObject.AddComponent<ElementalBody>();
						}
					}
				}
			}
			if (!Object.op_Implicit((Object)(object)mat))
			{
				return;
			}
			if ((Object)(object)val != (Object)(object)cam)
			{
				if (Object.op_Implicit((Object)(object)cam))
				{
					cam.RemoveCommandBuffer((CameraEvent)17, cb);
				}
				cam = val;
				if (Object.op_Implicit((Object)(object)cam))
				{
					cam.AddCommandBuffer((CameraEvent)17, cb);
				}
			}
			cb.Clear();
			if (!Object.op_Implicit((Object)(object)cam) || !on.Value)
			{
				return;
			}
			P.Push(cb);
			cb.SetGlobalFloat(SceneLight, SceneLevel());
			Light sun = RenderSettings.sun;
			cb.SetGlobalVector(SunDir, Vector4.op_Implicit(Object.op_Implicit((Object)(object)sun) ? (-((Component)sun).transform.forward) : Vector3.up));
			int num2 = Mathf.RoundToInt(P.GlobalShellCount.Value);
			foreach (ElementalBody item in ElementalBody.All)
			{
				if (!Object.op_Implicit((Object)(object)item))
				{
					continue;
				}
				val2 = ((Component)item).transform.position - ((Component)cam).transform.position;
				if (((Vector3)(ref val2)).sqrMagnitude > num)
				{
					continue;
				}
				float[] level = item.Level;
				cb.SetGlobalVector(ElemA, new Vector4(level[0], level[1], level[2], level[3]));
				cb.SetGlobalFloat(ElemB, level[4]);
				float[] age = item.Age;
				cb.SetGlobalVector(Age, new Vector4(age[0], age[1], age[2], age[3]));
				cb.SetGlobalFloat(Scale, item.PatternScale);
				SkinnedMeshRenderer[] renderers = item.Renderers;
				foreach (SkinnedMeshRenderer val3 in renderers)
				{
					if (!Object.op_Implicit((Object)(object)val3) || !((Renderer)val3).isVisible || !Object.op_Implicit((Object)(object)val3.sharedMesh))
					{
						continue;
					}
					for (int j = 0; j < val3.sharedMesh.subMeshCount; j++)
					{
						Material val4 = ((j < ((Renderer)val3).sharedMaterials.Length) ? ((Renderer)val3).sharedMaterials[j] : ((Renderer)val3).sharedMaterial);
						bool flag = Object.op_Implicit((Object)(object)val4) && Object.op_Implicit((Object)(object)val4.mainTexture) && (val4.IsKeywordEnabled("_ALPHATEST_ON") || (val4.renderQueue >= 2450 && val4.renderQueue < 3000));
						cb.SetGlobalTexture(Mask, RenderTargetIdentifier.op_Implicit((Texture)((Object.op_Implicit((Object)(object)val4) && Object.op_Implicit((Object)(object)val4.mainTexture)) ? ((object)val4.mainTexture) : ((object)Texture2D.grayTexture))));
						cb.SetGlobalFloat(Cutoff, (!flag) ? (-1f) : (val4.HasProperty("_Cutoff") ? val4.GetFloat("_Cutoff") : 0.5f));
						cb.DrawRenderer((Renderer)(object)val3, mat, j, 0);
						cb.DrawRenderer((Renderer)(object)val3, mat, j, 1);
						for (int k = 1; k <= num2; k++)
						{
							cb.SetGlobalFloat(ShellH, (float)k / (float)num2);
							cb.DrawRenderer((Renderer)(object)val3, mat, j, 2);
						}
					}
				}
			}
		}

		private static float SceneLevel()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: 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_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			Color val = (((int)RenderSettings.ambientMode == 3) ? RenderSettings.ambientLight : RenderSettings.ambientSkyColor);
			float num = ((Color)(ref val)).grayscale * 1.5f;
			if (Object.op_Implicit((Object)(object)RenderSettings.sun))
			{
				float num2 = num;
				float intensity = RenderSettings.sun.intensity;
				Color color = RenderSettings.sun.color;
				num = num2 + intensity * ((Color)(ref color)).grayscale * 0.35f;
			}
			return Mathf.Clamp01(num);
		}

		private void OnDestroy()
		{
			if (Object.op_Implicit((Object)(object)cam) && cb != null)
			{
				cam.RemoveCommandBuffer((CameraEvent)17, cb);
			}
		}
	}
	public static class P
	{
		public static ConfigEntry<float> GlobalStrength;

		public static ConfigEntry<float> GlobalPatternScale;

		public static ConfigEntry<float> GlobalStackDim;

		public static ConfigEntry<float> GlobalFlatNormals;

		public static ConfigEntry<float> GlobalShellCount;

		public static ConfigEntry<float> GlobalShellHeight;

		public static ConfigEntry<float> GlobalParticleDensity;

		public static ConfigEntry<float> GlobalParticleSize;

		public static ConfigEntry<float> FireIntensity;

		public static ConfigEntry<Color> FireCoolColor;

		public static ConfigEntry<Color> FireMidColor;

		public static ConfigEntry<Color> FireHotColor;

		public static ConfigEntry<float> FireGlow;

		public static ConfigEntry<float> FireSmolder;

		public static ConfigEntry<float> FireSmolderScale;

		public static ConfigEntry<float> FireFirelight;

		public static ConfigEntry<float> FireSeamAmount;

		public static ConfigEntry<float> FireSeamWidth;

		public static ConfigEntry<float> FireLickAmount;

		public static ConfigEntry<float> FireNoiseScale;

		public static ConfigEntry<float> FireRiseSpeed;

		public static ConfigEntry<float> FireFlickerSpeed;

		public static ConfigEntry<float> FireFlickerAmount;

		public static ConfigEntry<float> FireSootAmount;

		public static ConfigEntry<Color> FireSootColor;

		public static ConfigEntry<float> FireCharBuildUp;

		public static ConfigEntry<float> FireEmbers;

		public static ConfigEntry<float> FireShellFlames;

		public static ConfigEntry<float> FireTongueDensity;

		public static ConfigEntry<float> FireTongueSize;

		public static ConfigEntry<float> FireTongueRise;

		public static ConfigEntry<float> FireEmberDensity;

		public static ConfigEntry<float> FireEmberSize;

		public static ConfigEntry<float> FrostIntensity;

		public static ConfigEntry<Color> FrostTintColor;

		public static ConfigEntry<float> FrostTintAmount;

		public static ConfigEntry<Color> FrostCrustColor;

		public static ConfigEntry<float> FrostCrustBoost;

		public static ConfigEntry<float> FrostCoverage;

		public static ConfigEntry<float> FrostSpread;

		public static ConfigEntry<float> FrostCrackAmount;

		public static ConfigEntry<float> FrostCrackScale;

		public static ConfigEntry<float> FrostCrackWidth;

		public static ConfigEntry<float> FrostFacets;

		public static ConfigEntry<Color> FrostRimColor;

		public static ConfigEntry<float> FrostRimAmount;

		public static ConfigEntry<float> FrostGlintAmount;

		public static ConfigEntry<float> FrostGlintDensity;

		public static ConfigEntry<float> FrostGlintSize;

		public static ConfigEntry<float> FrostShellIce;

		public static ConfigEntry<float> FrostFlakeDensity;

		public static ConfigEntry<float> FrostFlakeSize;

		public static ConfigEntry<float> FrostFlakeFall;

		public static ConfigEntry<float> PoisonIntensity;

		public static ConfigEntry<Color> PoisonVeinColor;

		public static ConfigEntry<float> PoisonGlow;

		public static ConfigEntry<Color> PoisonTintColor;

		public static ConfigEntry<float> PoisonTintAmount;

		public static ConfigEntry<float> PoisonVeinScale;

		public static ConfigEntry<float> PoisonVeinWidth;

		public static ConfigEntry<float> PoisonVeinCoverage;

		public static ConfigEntry<float> PoisonPulseSpeed;

		public static ConfigEntry<float> PoisonPulseSharpness;

		public static ConfigEntry<float> PoisonPulseTravel;

		public static ConfigEntry<float> PoisonBubbles;

		public static ConfigEntry<float> PoisonSheenAmount;

		public static ConfigEntry<float> PoisonShellHaze;

		public static ConfigEntry<float> PoisonDripDensity;

		public static ConfigEntry<float> PoisonDripSize;

		public static ConfigEntry<float> LightningIntensity;

		public static ConfigEntry<Color> LightningArcColor;

		public static ConfigEntry<float> LightningGlow;

		public static ConfigEntry<float> LightningArcWidth;

		public static ConfigEntry<float> LightningArcDensity;

		public static ConfigEntry<float> LightningArcScale;

		public static ConfigEntry<float> LightningJagged;

		public static ConfigEntry<float> LightningBranches;

		public static ConfigEntry<float> LightningCrawl;

		public static ConfigEntry<float> LightningBurstRate;

		public static ConfigEntry<float> LightningBurstChance;

		public static ConfigEntry<float> LightningFlickerRate;

		public static ConfigEntry<Color> LightningRimColor;

		public static ConfigEntry<float> LightningRimAmount;

		public static ConfigEntry<float> LightningShellArcs;

		public static ConfigEntry<float> LightningLightFlash;

		public static ConfigEntry<float> LightningSparkDensity;

		public static ConfigEntry<float> LightningSparkSize;

		public static ConfigEntry<float> SpiritIntensity;

		public static ConfigEntry<Color> SpiritColor;

		public static ConfigEntry<Color> SpiritTintColor;

		public static ConfigEntry<float> SpiritTintAmount;

		public static ConfigEntry<float> SpiritHollow;

		public static ConfigEntry<float> SpiritRimAmount;

		public static ConfigEntry<float> SpiritRimPower;

		public static ConfigEntry<float> SpiritWispAmount;

		public static ConfigEntry<float> SpiritWispSpeed;

		public static ConfigEntry<float> SpiritShellAura;

		public static ConfigEntry<float> SpiritWispDensity;

		public static ConfigEntry<float> SpiritWispRise;

		public static ConfigEntry<bool> CombosEnabled;

		public static ConfigEntry<float> CombosReplace;

		public static ConfigEntry<bool> CombosSteamEnabled;

		public static ConfigEntry<float> CombosSteamStrength;

		public static ConfigEntry<Color> CombosSteamColor;

		public static ConfigEntry<bool> CombosOverloadEnabled;

		public static ConfigEntry<float> CombosOverloadStrength;

		public static ConfigEntry<Color> CombosOverloadColor;

		public static ConfigEntry<bool> CombosToxicBurnEnabled;

		public static ConfigEntry<float> CombosToxicBurnStrength;

		public static ConfigEntry<Color> CombosToxicBurnColor;

		public static ConfigEntry<bool> CombosGhostFireEnabled;

		public static ConfigEntry<float> CombosGhostFireStrength;

		public static ConfigEntry<Color> CombosGhostFireColor;

		public static ConfigEntry<bool> CombosConductiveIceEnabled;

		public static ConfigEntry<float> CombosConductiveIceStrength;

		public static ConfigEntry<Color> CombosConductiveIceColor;

		public static ConfigEntry<bool> CombosFrozenVeinsEnabled;

		public static ConfigEntry<float> CombosFrozenVeinsStrength;

		public static ConfigEntry<Color> CombosFrozenVeinsColor;

		public static ConfigEntry<bool> CombosWraithChillEnabled;

		public static ConfigEntry<float> CombosWraithChillStrength;

		public static ConfigEntry<Color> CombosWraithChillColor;

		public static ConfigEntry<bool> CombosCorrosiveSparksEnabled;

		public static ConfigEntry<float> CombosCorrosiveSparksStrength;

		public static ConfigEntry<Color> CombosCorrosiveSparksColor;

		public static ConfigEntry<bool> CombosSoulLightningEnabled;

		public static ConfigEntry<float> CombosSoulLightningStrength;

		public static ConfigEntry<Color> CombosSoulLightningColor;

		public static ConfigEntry<bool> CombosBlightEnabled;

		public static ConfigEntry<float> CombosBlightStrength;

		public static ConfigEntry<Color> CombosBlightColor;

		public static ConfigEntry<bool> CombosAllEnabled;

		public static ConfigEntry<float> CombosAllStrength;

		public static ConfigEntry<float> CombosAllGlow;

		public static ConfigEntry<float> CombosAllCycleSpeed;

		public static ConfigEntry<Color> CombosAllColor;

		private static readonly int id_GlobalStrength = Shader.PropertyToID("_GlobalStrength");

		private static readonly int id_GlobalPatternScale = Shader.PropertyToID("_GlobalPatternScale");

		private static readonly int id_GlobalStackDim = Shader.PropertyToID("_GlobalStackDim");

		private static readonly int id_GlobalFlatNormals = Shader.PropertyToID("_GlobalFlatNormals");

		private static readonly int id_GlobalShellCount = Shader.PropertyToID("_GlobalShellCount");

		private static readonly int id_GlobalShellHeight = Shader.PropertyToID("_GlobalShellHeight");

		private static readonly int id_GlobalParticleDensity = Shader.PropertyToID("_GlobalParticleDensity");

		private static readonly int id_GlobalParticleSize = Shader.PropertyToID("_GlobalParticleSize");

		private static readonly int id_FireIntensity = Shader.PropertyToID("_FireIntensity");

		private static readonly int id_FireCoolColor = Shader.PropertyToID("_FireCoolColor");

		private static readonly int id_FireMidColor = Shader.PropertyToID("_FireMidColor");

		private static readonly int id_FireHotColor = Shader.PropertyToID("_FireHotColor");

		private static readonly int id_FireGlow = Shader.PropertyToID("_FireGlow");

		private static readonly int id_FireSmolder = Shader.PropertyToID("_FireSmolder");

		private static readonly int id_FireSmolderScale = Shader.PropertyToID("_FireSmolderScale");

		private static readonly int id_FireFirelight = Shader.PropertyToID("_FireFirelight");

		private static readonly int id_FireSeamAmount = Shader.PropertyToID("_FireSeamAmount");

		private static readonly int id_FireSeamWidth = Shader.PropertyToID("_FireSeamWidth");

		private static readonly int id_FireLickAmount = Shader.PropertyToID("_FireLickAmount");

		private static readonly int id_FireNoiseScale = Shader.PropertyToID("_FireNoiseScale");

		private static readonly int id_FireRiseSpeed = Shader.PropertyToID("_FireRiseSpeed");

		private static readonly int id_FireFlickerSpeed = Shader.PropertyToID("_FireFlickerSpeed");

		private static readonly int id_FireFlickerAmount = Shader.PropertyToID("_FireFlickerAmount");

		private static readonly int id_FireSootAmount = Shader.PropertyToID("_FireSootAmount");

		private static readonly int id_FireSootColor = Shader.PropertyToID("_FireSootColor");

		private static readonly int id_FireCharBuildUp = Shader.PropertyToID("_FireCharBuildUp");

		private static readonly int id_FireEmbers = Shader.PropertyToID("_FireEmbers");

		private static readonly int id_FireShellFlames = Shader.PropertyToID("_FireShellFlames");

		private static readonly int id_FrostIntensity = Shader.PropertyToID("_FrostIntensity");

		private static readonly int id_FrostTintColor = Shader.PropertyToID("_FrostTintColor");

		private static readonly int id_FrostTintAmount = Shader.PropertyToID("_FrostTintAmount");

		private static readonly int id_FrostCrustColor = Shader.PropertyToID("_FrostCrustColor");

		private static readonly int id_FrostCrustBoost = Shader.PropertyToID("_FrostCrustBoost");

		private static readonly int id_FrostCoverage = Shader.PropertyToID("_FrostCoverage");

		private static readonly int id_FrostSpread = Shader.PropertyToID("_FrostSpread");

		private static readonly int id_FrostCrackAmount = Shader.PropertyToID("_FrostCrackAmount");

		private static readonly int id_FrostCrackScale = Shader.PropertyToID("_FrostCrackScale");

		private static readonly int id_FrostCrackWidth = Shader.PropertyToID("_FrostCrackWidth");

		private static readonly int id_FrostFacets = Shader.PropertyToID("_FrostFacets");

		private static readonly int id_FrostRimColor = Shader.PropertyToID("_FrostRimColor");

		private static readonly int id_FrostRimAmount = Shader.PropertyToID("_FrostRimAmount");

		private static readonly int id_FrostGlintAmount = Shader.PropertyToID("_FrostGlintAmount");

		private static readonly int id_FrostGlintDensity = Shader.PropertyToID("_FrostGlintDensity");

		private static readonly int id_FrostGlintSize = Shader.PropertyToID("_FrostGlintSize");

		private static readonly int id_FrostShellIce = Shader.PropertyToID("_FrostShellIce");

		private static readonly int id_PoisonIntensity = Shader.PropertyToID("_PoisonIntensity");

		private static readonly int id_PoisonVeinColor = Shader.PropertyToID("_PoisonVeinColor");

		private static readonly int id_PoisonGlow = Shader.PropertyToID("_PoisonGlow");

		private static readonly int id_PoisonTintColor = Shader.PropertyToID("_PoisonTintColor");

		private static readonly int id_PoisonTintAmount = Shader.PropertyToID("_PoisonTintAmount");

		private static readonly int id_PoisonVeinScale = Shader.PropertyToID("_PoisonVeinScale");

		private static readonly int id_PoisonVeinWidth = Shader.PropertyToID("_PoisonVeinWidth");

		private static readonly int id_PoisonVeinCoverage = Shader.PropertyToID("_PoisonVeinCoverage");

		private static readonly int id_PoisonPulseSpeed = Shader.PropertyToID("_PoisonPulseSpeed");

		private static readonly int id_PoisonPulseSharpness = Shader.PropertyToID("_PoisonPulseSharpness");

		private static readonly int id_PoisonPulseTravel = Shader.PropertyToID("_PoisonPulseTravel");

		private static readonly int id_PoisonBubbles = Shader.PropertyToID("_PoisonBubbles");

		private static readonly int id_PoisonSheenAmount = Shader.PropertyToID("_PoisonSheenAmount");

		private static readonly int id_PoisonShellHaze = Shader.PropertyToID("_PoisonShellHaze");

		private static readonly int id_LightningIntensity = Shader.PropertyToID("_LightningIntensity");

		private static readonly int id_LightningArcColor = Shader.PropertyToID("_LightningArcColor");

		private static readonly int id_LightningGlow = Shader.PropertyToID("_LightningGlow");

		private static readonly int id_LightningArcWidth = Shader.PropertyToID("_LightningArcWidth");

		private static readonly int id_LightningArcDensity = Shader.PropertyToID("_LightningArcDensity");

		private static readonly int id_LightningArcScale = Shader.PropertyToID("_LightningArcScale");

		private static readonly int id_LightningJagged = Shader.PropertyToID("_LightningJagged");

		private static readonly int id_LightningBranches = Shader.PropertyToID("_LightningBranches");

		private static readonly int id_LightningCrawl = Shader.PropertyToID("_LightningCrawl");

		private static readonly int id_LightningBurstRate = Shader.PropertyToID("_LightningBurstRate");

		private static readonly int id_LightningBurstChance = Shader.PropertyToID("_LightningBurstChance");

		private static readonly int id_LightningFlickerRate = Shader.PropertyToID("_LightningFlickerRate");

		private static readonly int id_LightningRimColor = Shader.PropertyToID("_LightningRimColor");

		private static readonly int id_LightningRimAmount = Shader.PropertyToID("_LightningRimAmount");

		private static readonly int id_LightningShellArcs = Shader.PropertyToID("_LightningShellArcs");

		private static readonly int id_LightningLightFlash = Shader.PropertyToID("_LightningLightFlash");

		private static readonly int id_SpiritIntensity = Shader.PropertyToID("_SpiritIntensity");

		private static readonly int id_SpiritColor = Shader.PropertyToID("_SpiritColor");

		private static readonly int id_SpiritTintColor = Shader.PropertyToID("_SpiritTintColor");

		private static readonly int id_SpiritTintAmount = Shader.PropertyToID("_SpiritTintAmount");

		private static readonly int id_SpiritHollow = Shader.PropertyToID("_SpiritHollow");

		private static readonly int id_SpiritRimAmount = Shader.PropertyToID("_SpiritRimAmount");

		private static readonly int id_SpiritRimPower = Shader.PropertyToID("_SpiritRimPower");

		private static readonly int id_SpiritWispAmount = Shader.PropertyToID("_SpiritWispAmount");

		private static readonly int id_SpiritWispSpeed = Shader.PropertyToID("_SpiritWispSpeed");

		private static readonly int id_SpiritShellAura = Shader.PropertyToID("_SpiritShellAura");

		private static readonly int id_CombosEnabled = Shader.PropertyToID("_CombosEnabled");

		private static readonly int id_CombosReplace = Shader.PropertyToID("_CombosReplace");

		private static readonly int id_CombosSteamEnabled = Shader.PropertyToID("_CombosSteamEnabled");

		private static readonly int id_CombosSteamStrength = Shader.PropertyToID("_CombosSteamStrength");

		private static readonly int id_CombosSteamColor = Shader.PropertyToID("_CombosSteamColor");

		private static readonly int id_CombosOverloadEnabled = Shader.PropertyToID("_CombosOverloadEnabled");

		private static readonly int id_CombosOverloadStrength = Shader.PropertyToID("_CombosOverloadStrength");

		private static readonly int id_CombosOverloadColor = Shader.PropertyToID("_CombosOverloadColor");

		private static readonly int id_CombosToxicBurnEnabled = Shader.PropertyToID("_CombosToxicBurnEnabled");

		private static readonly int id_CombosToxicBurnStrength = Shader.PropertyToID("_CombosToxicBurnStrength");

		private static readonly int id_CombosToxicBurnColor = Shader.PropertyToID("_CombosToxicBurnColor");

		private static readonly int id_CombosGhostFireEnabled = Shader.PropertyToID("_CombosGhostFireEnabled");

		private static readonly int id_CombosGhostFireStrength = Shader.PropertyToID("_CombosGhostFireStrength");

		private static readonly int id_CombosGhostFireColor = Shader.PropertyToID("_CombosGhostFireColor");

		private static readonly int id_CombosConductiveIceEnabled = Shader.PropertyToID("_CombosConductiveIceEnabled");

		private static readonly int id_CombosConductiveIceStrength = Shader.PropertyToID("_CombosConductiveIceStrength");

		private static readonly int id_CombosConductiveIceColor = Shader.PropertyToID("_CombosConductiveIceColor");

		private static readonly int id_CombosFrozenVeinsEnabled = Shader.PropertyToID("_CombosFrozenVeinsEnabled");

		private static readonly int id_CombosFrozenVeinsStrength = Shader.PropertyToID("_CombosFrozenVeinsStrength");

		private static readonly int id_CombosFrozenVeinsColor = Shader.PropertyToID("_CombosFrozenVeinsColor");

		private static readonly int id_CombosWraithChillEnabled = Shader.PropertyToID("_CombosWraithChillEnabled");

		private static readonly int id_CombosWraithChillStrength = Shader.PropertyToID("_CombosWraithChillStrength");

		private static readonly int id_CombosWraithChillColor = Shader.PropertyToID("_CombosWraithChillColor");

		private static readonly int id_CombosCorrosiveSparksEnabled = Shader.PropertyToID("_CombosCorrosiveSparksEnabled");

		private static readonly int id_CombosCorrosiveSparksStrength = Shader.PropertyToID("_CombosCorrosiveSparksStrength");

		private static readonly int id_CombosCorrosiveSparksColor = Shader.PropertyToID("_CombosCorrosiveSparksColor");

		private static readonly int id_CombosSoulLightningEnabled = Shader.PropertyToID("_CombosSoulLightningEnabled");

		private static readonly int id_CombosSoulLightningStrength = Shader.PropertyToID("_CombosSoulLightningStrength");

		private static readonly int id_CombosSoulLightningColor = Shader.PropertyToID("_CombosSoulLightningColor");

		private static readonly int id_CombosBlightEnabled = Shader.PropertyToID("_CombosBlightEnabled");

		private static readonly int id_CombosBlightStrength = Shader.PropertyToID("_CombosBlightStrength");

		private static readonly int id_CombosBlightColor = Shader.PropertyToID("_CombosBlightColor");

		private static readonly int id_CombosAllEnabled = Shader.PropertyToID("_CombosAllEnabled");

		private static readonly int id_CombosAllStrength = Shader.PropertyToID("_CombosAllStrength");

		private static readonly int id_CombosAllGlow = Shader.PropertyToID("_CombosAllGlow");

		private static readonly int id_CombosAllCycleSpeed = Shader.PropertyToID("_CombosAllCycleSpeed");

		private static readonly int id_CombosAllColor = Shader.PropertyToID("_CombosAllColor");

		public static void Bind(ConfigFile c)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Expected O, but got Unknown
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Expected O, but got Unknown
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Expected O, but got Unknown
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Expected O, but got Unknown
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Expected O, but got Unknown
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Expected O, but got Unknown
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Expected O, but got Unknown
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			//IL_027d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c4: Expected O, but got Unknown
			//IL_02f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fc: Expected O, but got Unknown
			//IL_032a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0334: Expected O, but got Unknown
			//IL_0362: Unknown result type (might be due to invalid IL or missing references)
			//IL_036c: Expected O, but got Unknown
			//IL_039a: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a4: Expected O, but got Unknown
			//IL_03d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03dc: Expected O, but got Unknown
			//IL_040a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0414: Expected O, but got Unknown
			//IL_0442: Unknown result type (might be due to invalid IL or missing references)
			//IL_044c: Expected O, but got Unknown
			//IL_047a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0484: Expected O, but got Unknown
			//IL_04b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bc: Expected O, but got Unknown
			//IL_04ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f4: Expected O, but got Unknown
			//IL_0522: Unknown result type (might be due to invalid IL or missing references)
			//IL_052c: Expected O, but got Unknown
			//IL_0550: Unknown result type (might be due to invalid IL or missing references)
			//IL_058d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0597: Expected O, but got Unknown
			//IL_05c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_05cf: Expected O, but got Unknown
			//IL_05fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0607: Expected O, but got Unknown
			//IL_0635: Unknown result type (might be due to invalid IL or missing references)
			//IL_063f: Expected O, but got Unknown
			//IL_066d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0677: Expected O, but got Unknown
			//IL_06a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_06af: Expected O, but got Unknown
			//IL_06dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e7: Expected O, but got Unknown
			//IL_0715: Unknown result type (might be due to invalid IL or missing references)
			//IL_071f: Expected O, but got Unknown
			//IL_074d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0757: Expected O, but got Unknown
			//IL_077b: Unknown result type (might be due to invalid IL or missing references)
			//IL_07b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c2: Expected O, but got Unknown
			//IL_07e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0823: Unknown result type (might be due to invalid IL or missing references)
			//IL_082d: Expected O, but got Unknown
			//IL_085b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0865: Expected O, but got Unknown
			//IL_0893: Unknown result type (might be due to invalid IL or missing references)
			//IL_089d: Expected O, but got Unknown
			//IL_08cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_08d5: Expected O, but got Unknown
			//IL_0903: Unknown result type (might be due to invalid IL or missing references)
			//IL_090d: Expected O, but got Unknown
			//IL_093b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0945: Expected O, but got Unknown
			//IL_0973: Unknown result type (might be due to invalid IL or missing references)
			//IL_097d: Expected O, but got Unknown
			//IL_09a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_09de: Unknown result type (might be due to invalid IL or missing references)
			//IL_09e8: Expected O, but got Unknown
			//IL_0a16: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a20: Expected O, but got Unknown
			//IL_0a4e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a58: Expected O, but got Unknown
			//IL_0a86: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a90: Expected O, but got Unknown
			//IL_0abe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ac8: Expected O, but got Unknown
			//IL_0af6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b00: Expected O, but got Unknown
			//IL_0b2e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b38: Expected O, but got Unknown
			//IL_0b66: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b70: Expected O, but got Unknown
			//IL_0b9e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ba8: Expected O, but got Unknown
			//IL_0bcc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c09: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c13: Expected O, but got Unknown
			//IL_0c37: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c74: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c7e: Expected O, but got Unknown
			//IL_0cac: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cb6: Expected O, but got Unknown
			//IL_0ce4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cee: Expected O, but got Unknown
			//IL_0d1c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d26: Expected O, but got Unknown
			//IL_0d54: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d5e: Expected O, but got Unknown
			//IL_0d8c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d96: Expected O, but got Unknown
			//IL_0dc4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dce: Expected O, but got Unknown
			//IL_0dfc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e06: Expected O, but got Unknown
			//IL_0e34: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e3e: Expected O, but got Unknown
			//IL_0e6c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e76: Expected O, but got Unknown
			//IL_0ea4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0eae: Expected O, but got Unknown
			//IL_0edc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ee6: Expected O, but got Unknown
			//IL_0f14: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f1e: Expected O, but got Unknown
			//IL_0f42: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f7f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f89: Expected O, but got Unknown
			//IL_0fb7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0fc1: Expected O, but got Unknown
			//IL_0fef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ff9: Expected O, but got Unknown
			//IL_1027: Unknown result type (might be due to invalid IL or missing references)
			//IL_1031: Expected O, but got Unknown
			//IL_105f: Unknown result type (might be due to invalid IL or missing references)
			//IL_1069: Expected O, but got Unknown
			//IL_1097: Unknown result type (might be due to invalid IL or missing references)
			//IL_10a1: Expected O, but got Unknown
			//IL_10cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_10d9: Expected O, but got Unknown
			//IL_1107: Unknown result type (might be due to invalid IL or missing references)
			//IL_1111: Expected O, but got Unknown
			//IL_113f: Unknown result type (might be due to invalid IL or missing references)
			//IL_1149: Expected O, but got Unknown
			//IL_1177: Unknown result type (might be due to invalid IL or missing references)
			//IL_1181: Expected O, but got Unknown
			//IL_11a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_11e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_11ec: Expected O, but got Unknown
			//IL_121a: Unknown result type (might be due to invalid IL or missing references)
			//IL_1224: Expected O, but got Unknown
			//IL_1252: Unknown result type (might be due to invalid IL or missing references)
			//IL_125c: Expected O, but got Unknown
			//IL_128a: Unknown result type (might be due to invalid IL or missing references)
			//IL_1294: Expected O, but got Unknown
			//IL_12c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_12cc: Expected O, but got Unknown
			//IL_12fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_1304: Expected O, but got Unknown
			//IL_1328: Unknown result type (might be due to invalid IL or missing references)
			//IL_135b: Unknown result type (might be due to invalid IL or missing references)
			//IL_1398: Unknown result type (might be due to invalid IL or missing references)
			//IL_13a2: Expected O, but got Unknown
			//IL_13d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_13da: Expected O, but got Unknown
			//IL_1408: Unknown result type (might be due to invalid IL or missing references)
			//IL_1412: Expected O, but got Unknown
			//IL_1440: Unknown result type (might be due to invalid IL or missing references)
			//IL_144a: Expected O, but got Unknown
			//IL_1478: Unknown result type (might be due to invalid IL or missing references)
			//IL_1482: Expected O, but got Unknown
			//IL_14b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_14ba: Expected O, but got Unknown
			//IL_14e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_14f2: Expected O, but got Unknown
			//IL_1520: Unknown result type (might be due to invalid IL or missing references)
			//IL_152a: Expected O, but got Unknown
			//IL_1558: Unknown result type (might be due to invalid IL or missing references)
			//IL_1562: Expected O, but got Unknown
			//IL_15ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_15b5: Expected O, but got Unknown
			//IL_15fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_1608: Expected O, but got Unknown
			//IL_162c: Unknown result type (might be due to invalid IL or missing references)
			//IL_1684: Unknown result type (might be due to invalid IL or missing references)
			//IL_168e: Expected O, but got Unknown
			//IL_16b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_170a: Unknown result type (might be due to invalid IL or missing references)
			//IL_1714: Expected O, but got Unknown
			//IL_1738: Unknown result type (might be due to invalid IL or missing references)
			//IL_1790: Unknown result type (might be due to invalid IL or missing references)
			//IL_179a: Expected O, but got Unknown
			//IL_17be: Unknown result type (might be due to invalid IL or missing references)
			//IL_1816: Unknown result type (might be due to invalid IL or missing references)
			//IL_1820: Expected O, but got Unknown
			//IL_1844: Unknown result type (might be due to invalid IL or missing references)
			//IL_189c: Unknown result type (might be due to invalid IL or missing references)
			//IL_18a6: Expected O, but got Unknown
			//IL_18ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_1922: Unknown result type (might be due to invalid IL or missing references)
			//IL_192c: Expected O, but got Unknown
			//IL_1950: Unknown result type (might be due to invalid IL or missing references)
			//IL_19a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_19b2: Expected O, but got Unknown
			//IL_19d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_1a2e: Unknown result type (might be due to invalid IL or missing references)
			//IL_1a38: Expected O, but got Unknown
			//IL_1a5c: Unknown result type (might be due to invalid IL or missing references)
			//IL_1ab4: Unknown result type (might be due to invalid IL or missing references)
			//IL_1abe: Expected O, but got Unknown
			//IL_1ae2: Unknown result type (might be due to invalid IL or missing references)
			//IL_1b3a: Unknown result type (might be due to invalid IL or missing references)
			//IL_1b44: Expected O, but got Unknown
			//IL_1b72: Unknown result type (might be due to invalid IL or missing references)
			//IL_1b7c: Expected O, but got Unknown
			//IL_1baa: Unknown result type (might be due to invalid IL or missing references)
			//IL_1bb4: Expected O, but got Unknown
			//IL_1bd8: Unknown result type (might be due to invalid IL or missing references)
			GlobalStrength = c.Bind<float>("Global", "Strength", 1f, new ConfigDescription("Overall brightness of the skin effects", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 2f), Array.Empty<object>()));
			GlobalPatternScale = c.Bind<float>("Global", "PatternScale", 1f, new ConfigDescription("Size of every surface pattern (bigger = larger, calmer patterns)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.3f, 3f), Array.Empty<object>()));
			GlobalStackDim = c.Bind<float>("Global", "StackDim", 1f, new ConfigDescription("How much stacked elements share one brightness budget (0 = each at full strength)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			GlobalFlatNormals = c.Bind<float>("Global", "FlatNormals", 1f, new ConfigDescription("Use the triangles' own facing for rims and fresnel (1) instead of the mesh's stored normals (0); faceted, low-poly look and immune to odd mesh normals", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			GlobalShellCount = c.Bind<float>("Global", "ShellCount", 3f, new ConfigDescription("Layers drawn just above the skin for flames, ice coat, haze, arcs and aura (0 = off, each layer costs one extra draw)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 4f), Array.Empty<object>()));
			GlobalShellHeight = c.Bind<float>("Global", "ShellHeight", 0.1f, new ConfigDescription("How far the outermost layer floats above the skin, in metres (for a Greydwarf-sized creature)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 0.25f), Array.Empty<object>()));
			GlobalParticleDensity = c.Bind<float>("Global", "ParticleDensity", 1f, new ConfigDescription("Multiplier for every overhaul particle count", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3f), Array.Empty<object>()));
			GlobalParticleSize = c.Bind<float>("Global", "ParticleSize", 1f, new ConfigDescription("Multiplier for every overhaul particle size", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.3f, 3f), Array.Empty<object>()));
			FireIntensity = c.Bind<float>("Fire", "Intensity", 1.25f, new ConfigDescription("Brightness of all fire glow", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3f), Array.Empty<object>()));
			FireCoolColor = c.Bind<Color>("Fire", "CoolColor", new Color(0.7674f, 0.2717f, 0.0999f, 1f), "Colour of the dimmest embers");
			FireMidColor = c.Bind<Color>("Fire", "MidColor", new Color(1f, 0.5469f, 0.2209f, 1f), "Colour of the main flame");
			FireHotColor = c.Bind<Color>("Fire", "HotColor", new Color(1f, 0.7736f, 0.4731f, 1f), "Colour of the hottest flame");
			FireGlow = c.Bind<float>("Fire", "Glow", 1.3f, new ConfigDescription("HDR boost for mid and hot colours (above 1 blooms)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 4f), Array.Empty<object>()));
			FireSmolder = c.Bind<float>("Fire", "Smolder", 1.5f, new ConfigDescription("Soft glowing heat patches under the char", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3f), Array.Empty<object>()));
			FireSmolderScale = c.Bind<float>("Fire", "SmolderScale", 1f, new ConfigDescription("Size of the heat patches (bigger = smaller patches)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.3f, 3f), Array.Empty<object>()));
			FireFirelight = c.Bind<float>("Fire", "Firelight", 0.3f, new ConfigDescription("Warm flickering light the flames cast on the body", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 2f), Array.Empty<object>()));
			FireSeamAmount = c.Bind<float>("Fire", "SeamAmount", 0f, new ConfigDescription("Glowing lava seams in the skin (off by default)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 2f), Array.Empty<object>()));
			FireSeamWidth = c.Bind<float>("Fire", "SeamWidth", 0.05f, new ConfigDescription("Seam thickness (0 = hairline, 1 = about 4 cm)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			FireLickAmount = c.Bind<float>("Fire", "LickAmount", 1.2f, new ConfigDescription("Flames licking at the silhouette", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 2f), Array.Empty<object>()));
			FireNoiseScale = c.Bind<float>("Fire", "NoiseScale", 0.7f, new ConfigDescription("Detail of the fire pattern", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.3f, 3f), Array.Empty<object>()));
			FireRiseSpeed = c.Bind<float>("Fire", "RiseSpeed", 1f, new ConfigDescription("How fast the fire pattern climbs", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3f), Array.Empty<object>()));
			FireFlickerSpeed = c.Bind<float>("Fire", "FlickerSpeed", 11f, new ConfigDescription("Flicker frequency", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 30f), Array.Empty<object>()));
			FireFlickerAmount = c.Bind<float>("Fire", "FlickerAmount", 0.18f, new ConfigDescription("Flicker depth", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 0.6f), Array.Empty<object>()));
			FireSootAmount = c.Bind<float>("Fire", "SootAmount", 0.75f, new ConfigDescription("Charred patches between the flames", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			FireSootColor = c.Bind<Color>("Fire", "SootColor", new Color(0.65f, 0.6012f, 0.5657f, 1f), "Colour multiplier of the char");
			FireCharBuildUp = c.Bind<float>("Fire", "CharBuildUp", 4f, new ConfigDescription("Seconds of burning before the char fully spreads (0 = instant)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 20f), Array.Empty<object>()));
			FireEmbers = c.Bind<float>("Fire", "Embers", 0.8f, new ConfigDescription("Round flickering ember spots in the char", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3f), Array.Empty<object>()));
			FireShellFlames = c.Bind<float>("Fire", "ShellFlames", 1.3f, new ConfigDescription("Flame tongues on the layers above the skin", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3f), Array.Empty<object>()));
			FireTongueDensity = c.Bind<float>("Fire", "TongueDensity", 10f, new ConfigDescription("Flame tongue particles per second per m² of body", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 40f), Array.Empty<object>()));
			FireTongueSize = c.Bind<float>("Fire", "TongueSize", 0.55f, new ConfigDescription("Flame tongue size in metres", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 1.2f), Array.Empty<object>()));
			FireTongueRise = c.Bind<float>("Fire", "TongueRise", 0.7f, new ConfigDescription("Flame tongue rise speed in m/s", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3f), Array.Empty<object>()));
			FireEmberDensity = c.Bind<float>("Fire", "EmberDensity", 1.6f, new ConfigDescription("Rising ember particles per second per m²", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 10f), Array.Empty<object>()));
			FireEmberSize = c.Bind<float>("Fire", "EmberSize", 0.035f, new ConfigDescription("Ember size in metres", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.01f, 0.15f), Array.Empty<object>()));
			FrostIntensity = c.Bind<float>("Frost", "Intensity", 0.5f, new ConfigDescription("Brightness of rime, rim and glints", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3f), Array.Empty<object>()));
			FrostTintColor = c.Bind<Color>("Frost", "TintColor", new Color(0.8756f, 0.9357f, 1f, 1f), "Cold tint over the whole body");
			FrostTintAmount = c.Bind<float>("Frost", "TintAmount", 0.85f, new ConfigDescription("Strength of the cold tint", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			FrostCrustColor = c.Bind<Color>("Frost", "CrustColor", new Color(0.9212f, 0.9547f, 1f, 1f), "Colour of the frost crust");
			FrostCrustBoost = c.Bind<float>("Frost", "CrustBoost", 1.15f, new ConfigDescription("How much the crust brightens the surface", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 3f), Array.Empty<object>()));
			FrostCoverage = c.Bind<float>("Frost", "Coverage", 0.4f, new ConfigDescription("How much of the body the crust covers", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			FrostSpread = c.Bind<float>("Frost", "Spread", 1.5f, new ConfigDescription("Seconds for the crust to creep over the body (0 = instant)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 10f), Array.Empty<object>()));
			FrostCrackAmount = c.Bind<float>("Frost", "CrackAmount", 0.6f, new ConfigDescription("Cracked-ice lines", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3f), Array.Empty<object>()));
			FrostCrackScale = c.Bind<float>("Frost", "CrackScale", 9f, new ConfigDescription("Crack cell density", (AcceptableValueBase)(object)new AcceptableValueRange<float>(2f, 30f), Array.Empty<object>()));
			FrostCrackWidth = c.Bind<float>("Frost", "CrackWidth", 0.07f, new ConfigDescription("Crack line width", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.01f, 0.3f), Array.Empty<object>()));
			FrostFacets = c.Bind<float>("Frost", "Facets", 0.6f, new ConfigDescription("Faceted crystal shading on the crust", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			FrostRimColor = c.Bind<Color>("Frost", "RimColor", new Color(0.6652f, 0.8095f, 0.9547f, 1f), "Icy rim colour");
			FrostRimAmount = c.Bind<float>("Frost", "RimAmount", 0.6f, new ConfigDescription("Icy rim strength", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3f), Array.Empty<object>()));
			FrostGlintAmount = c.Bind<float>("Frost", "GlintAmount", 1f, new ConfigDescription("Sparkling glints", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 4f), Array.Empty<object>()));
			FrostGlintDensity = c.Bind<float>("Frost", "GlintDensity", 0.007f, new ConfigDescription("Fraction of the crust that glints", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 0.05f), Array.Empty<object>()));
			FrostGlintSize = c.Bind<float>("Frost", "GlintSize", 30f, new ConfigDescription("Glint cells per metre (bigger = smaller glints)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(5f, 80f), Array.Empty<object>()));
			FrostShellIce = c.Bind<float>("Frost", "ShellIce", 0.15f, new ConfigDescription("Translucent ice coat on the layers above the skin", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 2f), Array.Empty<object>()));
			FrostFlakeDensity = c.Bind<float>("Frost", "FlakeDensity", 2.2f, new ConfigDescription("Falling flake particles per second per m²", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 15f), Array.Empty<object>()));
			FrostFlakeSize = c.Bind<float>("Frost", "FlakeSize", 0.035f, new ConfigDescription("Flake size in metres", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.01f, 0.15f), Array.Empty<object>()));
			FrostFlakeFall = c.Bind<float>("Frost", "FlakeFall", 0.32f, new ConfigDescription("Flake fall speed in m/s", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 2f), Array.Empty<object>()));
			PoisonIntensity = c.Bind<float>("Poison", "Intensity", 1f, new ConfigDescription("Brightness of veins and bubbles", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3f), Array.Empty<object>()));
			PoisonVeinColor = c.Bind<Color>("Poison", "VeinColor", new Color(0.6944f, 1f, 0.3318f, 1f), "Vein glow colour");
			PoisonGlow = c.Bind<float>("Poison", "Glow", 0.55f, new ConfigDescription("Vein glow strength (above 1 blooms)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 3f), Array.Empty<object>()));
			PoisonTintColor = c.Bind<Color>("Poison", "TintColor", new Color(0.9063f, 0.9867f, 0.8323f, 1f), "Sickly tint over the body");
			PoisonTintAmount = c.Bind<float>("Poison", "TintAmount", 0.75f, new ConfigDescription("Strength of the tint", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			PoisonVeinScale = c.Bind<float>("Poison", "VeinScale", 3f, new ConfigDescription("Vein detail", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 10f), Array.Empty<object>()));
			PoisonVeinWidth = c.Bind<float>("Poison", "VeinWidth", 0.02f, new ConfigDescription("Vein thickness in metres", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.005f, 0.12f), Array.Empty<object>()));
			PoisonVeinCoverage = c.Bind<float>("Poison", "VeinCoverage", 0.5f, new ConfigDescription("How much of the body has veins", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			PoisonPulseSpeed = c.Bind<float>("Poison", "PulseSpeed", 2.4f, new ConfigDescription("Pulse speed", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 10f), Array.Empty<object>()));
			PoisonPulseSharpness = c.Bind<float>("Poison", "PulseSharpness", 3f, new ConfigDescription("How short and punchy each pulse is", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 10f), Array.Empty<object>()));
			PoisonPulseTravel = c.Bind<float>("Poison", "PulseTravel", 5f, new ConfigDescription("How fast pulses travel up the body", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 15f), Array.Empty<object>()));
			PoisonBubbles = c.Bind<float>("Poison", "Bubbles", 0.6f, new ConfigDescription("Bubbles that swell and pop on the skin", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3f), Array.Empty<object>()));
			PoisonSheenAmount = c.Bind<float>("Poison", "SheenAmount", 0.2f, new ConfigDescription("Wet highlight from the sun and rim", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3f), Array.Empty<object>()));
			PoisonShellHaze = c.Bind<float>("Poison", "ShellHaze", 0.25f, new ConfigDescription("Toxic haze on the layers above the skin", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 2f), Array.Empty<object>()));
			PoisonDripDensity = c.Bind<float>("Poison", "DripDensity", 1.3f, new ConfigDescription("Drip particles per second per m²", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 10f), Array.Empty<object>()));
			PoisonDripSize = c.Bind<float>("Poison", "DripSize", 0.04f, new ConfigDescription("Drip size in metres", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.01f, 0.15f), Array.Empty<object>()));
			LightningIntensity = c.Bind<float>("Lightning", "Intensity", 1f, new ConfigDescription("Brightness of arcs and rim", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3f), Array.Empty<object>()));
			LightningArcColor = c.Bind<Color>("Lightning", "ArcColor", new Color(0.5169f, 0.8153f, 1f, 1f), "Arc colour");
			LightningGlow = c.Bind<float>("Lightning", "Glow", 2f, new ConfigDescription("Arc HDR boost (above 1 blooms)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 5f), Array.Empty<object>()));
			LightningArcWidth = c.Bind<float>("Lightning", "ArcWidth", 1f, new ConfigDescription("Arc thickness", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.3f, 4f), Array.Empty<object>()));
			LightningArcDensity = c.Bind<float>("Lightning", "ArcDensity", 0.36f, new ConfigDescription("How much of the body sparks per flash", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			LightningArcScale = c.Bind<float>("Lightning", "ArcScale", 2.6f, new ConfigDescription("Arc length (smaller = longer arcs)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 8f), Array.Empty<object>()));
			LightningJagged = c.Bind<float>("Lightning", "Jagged", 0.4f, new ConfigDescription("Zigzag kinks in the arcs", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			LightningBranches = c.Bind<float>("Lightning", "Branches", 0.6f, new ConfigDescription("Short side branches", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 2f), Array.Empty<object>()));
			LightningCrawl = c.Bind<float>("Lightning", "Crawl", 0f, new ConfigDescription("Arcs slide over the body instead of only flashing", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3f), Array.Empty<object>()));
			LightningBurstRate = c.Bind<float>("Lightning", "BurstRate", 3f, new ConfigDescription("Burst windows per second", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 10f), Array.Empty<object>()));
			LightningBurstChance = c.Bind<float>("Lightning", "BurstChance", 0.5f, new ConfigDescription("Chance each window fires", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			LightningFlickerRate = c.Bind<float>("Lightning", "FlickerRate", 15f, new ConfigDescription("Arc re-randomising rate during a burst", (AcceptableValueBase)(object)new AcceptableValueRange<float>(4f, 40f), Array.Empty<object>()));
			LightningRimColor = c.Bind<Color>("Lightning", "RimColor", new Color(0.4845f, 0.7611f, 1f, 1f), "Charged rim colour");
			LightningRimAmount = c.Bind<float>("Lightning", "RimAmount", 1f, new ConfigDescription("Charged rim strength", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3f), Array.Empty<object>()));
			LightningShellArcs = c.Bind<float>("Lightning", "ShellArcs", 0.6f, new ConfigDescription("Arcs jumping in the air just above the skin", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3f), Array.Empty<object>()));
			LightningLightFlash = c.Bind<float>("Lightning", "LightFlash", 1f, new ConfigDescription("How hard the creature's light flashes with bursts", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3f), Array.Empty<object>()));
			LightningSparkDensity = c.Bind<float>("Lightning", "SparkDensity", 2.5f, new ConfigDescription("Spark particles per second per m²", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 15f), Array.Empty<object>()));
			LightningSparkSize = c.Bind<float>("Lightning", "SparkSize", 0.23f, new ConfigDescription("Spark size in metres", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.05f, 0.8f), Array.Empty<object>()));
			SpiritIntensity = c.Bind<float>("Spirit", "Intensity", 1f, new ConfigDescription("Brightness of rim and wisps", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3f), Array.Empty<object>()));
			SpiritColor = c.Bind<Color>("Spirit", "Color", new Color(0.4956f, 1f, 0.9113f, 1f), "Spirit glow colour");
			SpiritTintColor = c.Bind<Color>("Spirit", "TintColor", new Color(0.865f, 0.9547f, 0.9453f, 1f), "Ghostly tint over the body");
			SpiritTintAmount = c.Bind<float>("Spirit", "TintAmount", 0.5f, new ConfigDescription("Strength of the tint", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			SpiritHollow = c.Bind<float>("Spirit", "Hollow", 0.2f, new ConfigDescription("Darkens the body's interior so it reads as hollow", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			SpiritRimAmount = c.Bind<float>("Spirit", "RimAmount", 1f, new ConfigDescription("Rim glow strength", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3f), Array.Empty<object>()));
			SpiritRimPower = c.Bind<float>("Spirit", "RimPower", 3f, new ConfigDescription("Rim sharpness", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 8f), Array.Empty<object>()));
			SpiritWispAmount = c.Bind<float>("Spirit", "WispAmount", 1f, new ConfigDescription("Wisps crawling at the silhouette", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3f), Array.Empty<object>()));
			SpiritWispSpeed = c.Bind<float>("Spirit", "WispSpeed", 0.9f, new ConfigDescription("Wisp rise speed", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3f), Array.Empty<object>()));
			SpiritShellAura = c.Bind<float>("Spirit", "ShellAura", 0.5f, new ConfigDescription("Ghostly aura on the layers above the skin", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3f), Array.Empty<object>()));
			SpiritWispDensity = c.Bind<float>("Spirit", "WispDensity", 1.2f, new ConfigDescription("Rising wisp particles per second per m²", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 10f), Array.Empty<object>()));
			SpiritWispRise = c.Bind<float>("Spirit", "WispRise", 0.58f, new ConfigDescription("Wisp rise speed in m/s", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3f), Array.Empty<object>()));
			CombosEnabled = c.Bind<bool>("Combos", "Enabled", true, "Master switch for all combo effects");
			CombosReplace = c.Bind<float>("Combos", "Replace", 0.7f, new ConfigDescription("How much a combo fades out its parent elements' own looks (1 = only the combo shows)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			CombosSteamEnabled = c.Bind<bool>("Combos", "SteamEnabled", true, "Combo fire + frost: hissing vapour rises, wet sheen, a faint ember core");
			CombosSteamStrength = c.Bind<float>("Combos", "SteamStrength", 1f, new ConfigDescription("Strength of the Steam combo", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3f), Array.Empty<object>()));
			CombosSteamColor = c.Bind<Color>("Combos", "SteamColor", new Color(0.9309f, 0.9453f, 0.9547f, 1f), "Main colour of the Steam combo (also tints the creature's light)");
			CombosOverloadEnabled = c.Bind<bool>("Combos", "OverloadEnabled", true, "Combo fire + lightning: orange-white arcs crackle over scorched skin");
			CombosOverloadStrength = c.Bind<float>("Combos", "OverloadStrength", 1f, new ConfigDescription("Strength of the Overload combo", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3f), Array.Empty<object>()));
			CombosOverloadColor = c.Bind<Color>("Combos", "OverloadColor", new Color(1f, 0