using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.Rendering.Universal;
using UnityEngine.SceneManagement;
using UnityEngine.VFX;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("BloodColor")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("BloodColor")]
[assembly: AssemblyTitle("BloodColor")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[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 BloodColor
{
	public enum TintMode
	{
		Replace,
		Multiply,
		Vanilla
	}
	internal class BloodConfig
	{
		public const string DefaultHex = "B01C1C";

		private const int DefaultR = 176;

		private const int DefaultG = 28;

		private const int DefaultB = 28;

		public ConfigEntry<string> Hex;

		public ConfigEntry<int> R;

		public ConfigEntry<int> G;

		public ConfigEntry<int> B;

		public ConfigEntry<TintMode> Mode;

		public ConfigEntry<float> Opacity;

		public ConfigEntry<float> Intensity;

		public ConfigEntry<bool> EnableBlood;

		public ConfigEntry<bool> DoParticles;

		public ConfigEntry<bool> DoDecals;

		public ConfigEntry<bool> LogEffects;

		public Color Tint = Color.red;

		private bool _syncing;

		public float AlphaFactor => ((Mode.Value == TintMode.Vanilla) ? 1f : Tint.a) * Opacity.Value;

		public event Action Changed;

		public BloodConfig(ConfigFile file)
		{
			//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_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Expected O, but got Unknown
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Expected O, but got Unknown
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Expected O, but got Unknown
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Expected O, but got Unknown
			Hex = file.Bind<string>("Blood", "Color", "B01C1C", "Blood colour as a hex code, like B01C1C. Paste one from any colour picker. RGB, RRGGBB or RRGGBBAA, # optional, and names like 'red' or 'lime' work too.\nThis and the R/G/B sliders below are the same setting - change either one and the other follows.\nHeads up: you can't type letters into this box from the in-game Mod Menu. Use the sliders there, or edit this file.");
			R = file.Bind<int>("Blood", "R", 176, new ConfigDescription("Red, 0-255. Moves with the Color setting.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 255), Array.Empty<object>()));
			G = file.Bind<int>("Blood", "G", 28, new ConfigDescription("Green, 0-255. Moves with the Color setting.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 255), Array.Empty<object>()));
			B = file.Bind<int>("Blood", "B", 28, new ConfigDescription("Blue, 0-255. Moves with the Color setting.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 255), Array.Empty<object>()));
			Mode = file.Bind<TintMode>("Blood", "Mode", TintMode.Replace, "Replace = use your colour as-is.\nMultiply = tint the original, which keeps the built-in shading but can only darken.\nVanilla = don't recolour. Opacity, Intensity and EnableBlood still work.");
			Opacity = file.Bind<float>("Blood", "Opacity", 1f, new ConfigDescription("How visible blood is. 1 is normal, 0 is invisible.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			Intensity = file.Bind<float>("Blood", "Intensity", 1f, new ConfigDescription("Brightness. Above 1 goes HDR, which is how you get blood that glows. A hex code can't describe anything brighter than 1 on its own, hence this.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 8f), Array.Empty<object>()));
			EnableBlood = file.Bind<bool>("Blood", "EnableBlood", true, "Turn this off for no blood at all. Separate from the game's own Blood option - either one being off means no blood.");
			DoParticles = file.Bind<bool>("Targets", "Particles", true, "Recolour the blood spray.");
			DoDecals = file.Bind<bool>("Targets", "Decals", true, "Recolour the splatter left on the ground.");
			LogEffects = file.Bind<bool>("Advanced", "LogEffects", false, "Dump the blood effects the mod found to the BepInEx log - shaders, materials, VFX properties. Turn this on before reporting a problem.");
			PullFromHex();
			file.SettingChanged += delegate(object _, SettingChangedEventArgs e)
			{
				if (!_syncing)
				{
					if ((object)e.ChangedSetting == Hex)
					{
						PullFromHex();
					}
					else if ((object)e.ChangedSetting == R || (object)e.ChangedSetting == G || (object)e.ChangedSetting == B)
					{
						PullFromSliders();
					}
					this.Changed?.Invoke();
				}
			};
		}

		private void PullFromHex()
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: 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_006f: 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)
			if (!TryParse(Hex.Value, out var color))
			{
				Plugin.Log.LogWarning((object)("Couldn't read colour '" + Hex.Value + "', using B01C1C instead."));
				TryParse("B01C1C", out color);
			}
			Tint = color;
			_syncing = true;
			R.Value = To255(color.r);
			G.Value = To255(color.g);
			B.Value = To255(color.b);
			_syncing = false;
		}

		private void PullFromSliders()
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			Tint = new Color((float)R.Value / 255f, (float)G.Value / 255f, (float)B.Value / 255f, Tint.a);
			_syncing = true;
			Hex.Value = ((Tint.a >= 1f) ? ColorUtility.ToHtmlStringRGB(Tint) : ColorUtility.ToHtmlStringRGBA(Tint));
			_syncing = false;
		}

		private static int To255(float v)
		{
			return Mathf.Clamp(Mathf.RoundToInt(v * 255f), 0, 255);
		}

		public static bool TryParse(string raw, out Color color)
		{
			//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)
			color = Color.red;
			if (string.IsNullOrEmpty(raw))
			{
				return false;
			}
			string text = raw.Trim();
			if (text.Length == 0)
			{
				return false;
			}
			if (text[0] != '#' && !char.IsLetter(text[0]))
			{
				text = "#" + text;
			}
			return ColorUtility.TryParseHtmlString(text, ref color);
		}

		public Color CombineRgb(Color original)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: 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_006b: 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_008a: 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)
			Color val = default(Color);
			switch (Mode.Value)
			{
			case TintMode.Replace:
				((Color)(ref val))..ctor(Tint.r, Tint.g, Tint.b, original.a);
				break;
			case TintMode.Multiply:
				((Color)(ref val))..ctor(original.r * Tint.r, original.g * Tint.g, original.b * Tint.b, original.a);
				break;
			default:
				val = original;
				break;
			}
			float value = Intensity.Value;
			return new Color(val.r * value, val.g * value, val.b * value, original.a);
		}

		public Color Combine(Color original)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			Color result = CombineRgb(original);
			result.a = Mathf.Clamp01(original.a * AlphaFactor);
			return result;
		}
	}
	internal static class BloodTinter
	{
		private class ParticleTarget
		{
			public ParticleSystem System;

			public string Owner;

			public MinMaxGradient Original;

			public ParticleSystemRenderer Renderer;

			public int ColorProp = -1;

			public Color OriginalMaterialColor;
		}

		private class DecalTarget
		{
			public string Name;

			public List<DecalProjector> Projectors;

			public Material Material;

			public int ColorProp = -1;

			public Color OriginalColor;

			public float OriginalFade;
		}

		private class VfxTarget
		{
			public VisualEffect Effect;

			public string Property;

			public bool IsGradient;

			public Color OriginalColor;

			public Gradient OriginalGradient;
		}

		private class Original
		{
			public Material Material;

			public float Fade;
		}

		public static readonly string[] ParticleNames = new string[3] { "Blood", "BloodSmall", "BloodDirectional" };

		public const string DecalPrefix = "BloodDecal";

		private static readonly string[] DecalNames = new string[3] { "BloodDecal1", "BloodDecal2", "BloodDecal3" };

		public const string VfxName = "SmallBloodExplosion";

		private static readonly string[] ColorProps = new string[5] { "_BaseColor", "_Color", "_TintColor", "_MainColor", "_UnlitColor" };

		private static readonly List<ParticleTarget> Particles = new List<ParticleTarget>();

		private static readonly List<DecalTarget> Decals = new List<DecalTarget>();

		private static readonly Dictionary<string, Original> Pristine = new Dictionary<string, Original>();

		private static VfxTarget Vfx;

		private static readonly MaterialPropertyBlock Block = new MaterialPropertyBlock();

		private static bool _warnedVfx;

		private static bool _warnedDecal;

		private static BloodConfig Cfg => Plugin.Cfg;

		public static int FindParticles()
		{
			//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_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			List<ParticleTarget> list = new List<ParticleTarget>(Particles);
			Particles.Clear();
			Dictionary<string, ParticleType> particles = ParticleManager._particles;
			if (particles == null || particles.Count == 0)
			{
				return 0;
			}
			string[] particleNames = ParticleNames;
			foreach (string text in particleNames)
			{
				if (!particles.TryGetValue(text, out var value) || (Object)(object)value?.ParticleSystem == (Object)null)
				{
					continue;
				}
				ParticleSystem[] componentsInChildren = ((Component)value.ParticleSystem).GetComponentsInChildren<ParticleSystem>(true);
				foreach (ParticleSystem ps in componentsInChildren)
				{
					ParticleTarget particleTarget = list.Find((ParticleTarget x) => x.System == ps);
					if (particleTarget == null)
					{
						ParticleTarget obj = new ParticleTarget
						{
							System = ps,
							Owner = text
						};
						MainModule main = ps.main;
						obj.Original = Copy(((MainModule)(ref main)).startColor);
						obj.Renderer = ((Component)ps).GetComponent<ParticleSystemRenderer>();
						particleTarget = obj;
						Material val = (Object.op_Implicit((Object)(object)particleTarget.Renderer) ? ((Renderer)particleTarget.Renderer).sharedMaterial : null);
						if ((Object)(object)val != (Object)null)
						{
							particleTarget.ColorProp = FindColorProp(val);
							if (particleTarget.ColorProp >= 0)
							{
								particleTarget.OriginalMaterialColor = val.GetColor(particleTarget.ColorProp);
							}
						}
					}
					Particles.Add(particleTarget);
				}
			}
			return Particles.Count;
		}

		public static int FindDecals()
		{
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Expected O, but got Unknown
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			List<DecalTarget> list = new List<DecalTarget>(Decals);
			Decals.Clear();
			Dictionary<string, List<DecalProjector>> decals = DecalManager._decals;
			if (decals == null || decals.Count == 0)
			{
				DestroyMaterials(list);
				return 0;
			}
			string[] decalNames = DecalNames;
			foreach (string text in decalNames)
			{
				if (!decals.TryGetValue(text, out var pool) || pool == null || pool.Count == 0)
				{
					continue;
				}
				DecalTarget decalTarget = list.Find((DecalTarget x) => x.Projectors == pool);
				if (decalTarget != null)
				{
					Decals.Add(decalTarget);
					continue;
				}
				DecalProjector val = pool[0];
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				if (!Pristine.TryGetValue(text, out var value) || (Object)(object)value.Material == (Object)null)
				{
					if ((Object)(object)val.material == (Object)null)
					{
						continue;
					}
					value = new Original
					{
						Material = val.material,
						Fade = val.fadeFactor
					};
					Pristine[text] = value;
				}
				DecalTarget decalTarget2 = new DecalTarget
				{
					Name = text,
					Projectors = pool,
					Material = new Material(value.Material)
					{
						name = ((Object)value.Material).name + " (BloodColor)"
					},
					OriginalFade = value.Fade
				};
				decalTarget2.ColorProp = FindColorProp(decalTarget2.Material);
				if (decalTarget2.ColorProp >= 0)
				{
					decalTarget2.OriginalColor = decalTarget2.Material.GetColor(decalTarget2.ColorProp);
				}
				else if (!_warnedDecal)
				{
					_warnedDecal = true;
					ManualLogSource log = Plugin.Log;
					string[] obj = new string[5] { "Decal ", text, " uses shader '", null, null };
					Shader shader = decalTarget2.Material.shader;
					obj[3] = ((shader != null) ? ((Object)shader).name : null);
					obj[4] = "' and I can't find a colour property on it. Turn on LogEffects and send me the shader name.";
					log.LogWarning((object)string.Concat(obj));
				}
				foreach (DecalProjector item in pool)
				{
					if ((Object)(object)item != (Object)null)
					{
						item.material = decalTarget2.Material;
					}
				}
				Decals.Add(decalTarget2);
			}
			list.RemoveAll((DecalTarget x) => Decals.Contains(x));
			DestroyMaterials(list);
			return Decals.Count;
		}

		public static int FindVfx()
		{
			//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)
			VfxTarget vfx = Vfx;
			Vfx = null;
			Dictionary<string, VisualEffect> allVfx = VFXManager._allVfx;
			if (allVfx == null || !allVfx.TryGetValue("SmallBloodExplosion", out var value) || (Object)(object)value == (Object)null)
			{
				return 0;
			}
			if (vfx != null && vfx.Effect == value)
			{
				Vfx = vfx;
				return 1;
			}
			foreach (string item in ExposedNames(value))
			{
				if (value.HasVector4(item))
				{
					Vfx = new VfxTarget
					{
						Effect = value,
						Property = item,
						OriginalColor = Color.op_Implicit(value.GetVector4(item))
					};
					break;
				}
				if (value.HasGradient(item))
				{
					Vfx = new VfxTarget
					{
						Effect = value,
						Property = item,
						IsGradient = true,
						OriginalGradient = value.GetGradient(item)
					};
					break;
				}
			}
			if (Vfx == null)
			{
				if (!_warnedVfx)
				{
					_warnedVfx = true;
					Plugin.Log.LogDebug((object)"SmallBloodExplosion exposes no colour property; gib burst left alone.");
				}
				return 0;
			}
			Plugin.Log.LogInfo((object)("SmallBloodExplosion: using property '" + Vfx.Property + "'."));
			return 1;
		}

		public static void ResetVfxWarning()
		{
			_warnedVfx = false;
		}

		private static List<string> ExposedNames(VisualEffect effect)
		{
			//IL_0056: 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_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: 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_008d: Unknown result type (might be due to invalid IL or missing references)
			List<string> list = new List<string>();
			VisualEffectAsset visualEffectAsset = effect.visualEffectAsset;
			if ((Object)(object)visualEffectAsset == (Object)null)
			{
				return list;
			}
			List<VFXExposedProperty> list2 = new List<VFXExposedProperty>();
			try
			{
				visualEffectAsset.GetExposedProperties(list2);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogDebug((object)("Couldn't read exposed properties off SmallBloodExplosion: " + ex.Message));
				return list;
			}
			foreach (VFXExposedProperty item in list2)
			{
				if (item.type == typeof(Vector4) || item.type == typeof(Color) || item.type == typeof(Gradient))
				{
					list.Add(item.name);
				}
			}
			return list;
		}

		public static void Apply()
		{
			if (Cfg.DoParticles.Value)
			{
				ApplyParticles();
			}
			if (Cfg.DoDecals.Value)
			{
				ApplyDecals();
			}
			if (Vfx != null && (Object)(object)Vfx.Effect != (Object)null)
			{
				ApplyVfx();
			}
		}

		private static void ApplyParticles()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			foreach (ParticleTarget particle in Particles)
			{
				if (!((Object)(object)particle.System == (Object)null))
				{
					MainModule main = particle.System.main;
					((MainModule)(ref main)).startColor = BuildStartColor(particle.Original);
					if (!((Object)(object)particle.Renderer == (Object)null) && particle.ColorProp >= 0)
					{
						Color val = Cfg.CombineRgb(particle.OriginalMaterialColor);
						val.a = particle.OriginalMaterialColor.a;
						((Renderer)particle.Renderer).GetPropertyBlock(Block);
						Block.SetColor(particle.ColorProp, val);
						((Renderer)particle.Renderer).SetPropertyBlock(Block);
					}
				}
			}
		}

		private static void ApplyDecals()
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			foreach (DecalTarget decal in Decals)
			{
				if ((Object)(object)decal.Material != (Object)null && decal.ColorProp >= 0)
				{
					Color val = Cfg.Combine(decal.OriginalColor);
					val.a = decal.OriginalColor.a;
					decal.Material.SetColor(decal.ColorProp, val);
				}
				float fadeFactor = Mathf.Clamp01(decal.OriginalFade * Cfg.AlphaFactor);
				foreach (DecalProjector projector in decal.Projectors)
				{
					if ((Object)(object)projector != (Object)null)
					{
						projector.fadeFactor = fadeFactor;
					}
				}
			}
		}

		private static void ApplyVfx()
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			if (Vfx.IsGradient)
			{
				Vfx.Effect.SetGradient(Vfx.Property, TintGradient(Vfx.OriginalGradient));
			}
			else
			{
				Vfx.Effect.SetVector4(Vfx.Property, Color.op_Implicit(Cfg.Combine(Vfx.OriginalColor)));
			}
		}

		private static MinMaxGradient BuildStartColor(MinMaxGradient src)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected I4, but got Unknown
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: 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_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			bool flag = Cfg.Mode.Value == TintMode.Vanilla;
			float alphaFactor = Cfg.AlphaFactor;
			float scale = (flag ? 1f : (1f / Mathf.Max(0.0001f, MaxLuminance(src))));
			ParticleSystemGradientMode mode = ((MinMaxGradient)(ref src)).mode;
			switch ((int)mode)
			{
			case 0:
				return new MinMaxGradient(Flatten(((MinMaxGradient)(ref src)).color, flag, scale, alphaFactor));
			case 2:
				return new MinMaxGradient(Flatten(((MinMaxGradient)(ref src)).colorMin, flag, scale, alphaFactor), Flatten(((MinMaxGradient)(ref src)).colorMax, flag, scale, alphaFactor));
			case 1:
			case 4:
			{
				MinMaxGradient result = default(MinMaxGradient);
				((MinMaxGradient)(ref result))..ctor(FlattenGradient(((MinMaxGradient)(ref src)).gradient, flag, scale, alphaFactor));
				((MinMaxGradient)(ref result)).mode = ((MinMaxGradient)(ref src)).mode;
				return result;
			}
			case 3:
				return new MinMaxGradient(FlattenGradient(((MinMaxGradient)(ref src)).gradientMin, flag, scale, alphaFactor), FlattenGradient(((MinMaxGradient)(ref src)).gradientMax, flag, scale, alphaFactor));
			default:
				return src;
			}
		}

		private static Color Flatten(Color c, bool vanilla, float scale, float alpha)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: 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_0017: 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_0024: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Clamp01(c.a * alpha);
			if (vanilla)
			{
				return new Color(c.r, c.g, c.b, num);
			}
			float num2 = Mathf.Clamp01(((Color)(ref c)).grayscale * scale);
			return new Color(num2, num2, num2, num);
		}

		private static Gradient FlattenGradient(Gradient src, bool vanilla, float scale, float alpha)
		{
			//IL_0022: 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_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: 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_00b5: 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_00c8: Expected O, but got Unknown
			if (src == null)
			{
				return null;
			}
			GradientColorKey[] colorKeys = src.colorKeys;
			GradientColorKey[] array = (GradientColorKey[])(object)new GradientColorKey[colorKeys.Length];
			for (int i = 0; i < colorKeys.Length; i++)
			{
				Color val = Flatten(colorKeys[i].color, vanilla, scale, 1f);
				array[i] = new GradientColorKey(val, colorKeys[i].time);
			}
			GradientAlphaKey[] alphaKeys = src.alphaKeys;
			GradientAlphaKey[] array2 = (GradientAlphaKey[])(object)new GradientAlphaKey[alphaKeys.Length];
			for (int j = 0; j < alphaKeys.Length; j++)
			{
				array2[j] = new GradientAlphaKey(Mathf.Clamp01(alphaKeys[j].alpha * alpha), alphaKeys[j].time);
			}
			Gradient val2 = new Gradient
			{
				mode = src.mode
			};
			val2.SetKeys(array, array2);
			return val2;
		}

		private static float MaxLuminance(MinMaxGradient g)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected I4, but got Unknown
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: 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)
			ParticleSystemGradientMode mode = ((MinMaxGradient)(ref g)).mode;
			Color val;
			switch ((int)mode)
			{
			case 0:
				val = ((MinMaxGradient)(ref g)).color;
				return ((Color)(ref val)).grayscale;
			case 2:
			{
				val = ((MinMaxGradient)(ref g)).colorMin;
				float grayscale = ((Color)(ref val)).grayscale;
				val = ((MinMaxGradient)(ref g)).colorMax;
				return Mathf.Max(grayscale, ((Color)(ref val)).grayscale);
			}
			case 1:
			case 4:
				return MaxLuminance(((MinMaxGradient)(ref g)).gradient);
			case 3:
				return Mathf.Max(MaxLuminance(((MinMaxGradient)(ref g)).gradientMin), MaxLuminance(((MinMaxGradient)(ref g)).gradientMax));
			default:
				return 1f;
			}
		}

		private static float MaxLuminance(Gradient g)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			if (g == null)
			{
				return 1f;
			}
			float num = 0f;
			GradientColorKey[] colorKeys = g.colorKeys;
			for (int i = 0; i < colorKeys.Length; i++)
			{
				GradientColorKey val = colorKeys[i];
				num = Mathf.Max(num, ((Color)(ref val.color)).grayscale);
			}
			return num;
		}

		private static Gradient TintGradient(Gradient src)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: 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_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Expected O, but got Unknown
			if (src == null)
			{
				return null;
			}
			GradientColorKey[] colorKeys = src.colorKeys;
			GradientColorKey[] array = (GradientColorKey[])(object)new GradientColorKey[colorKeys.Length];
			for (int i = 0; i < colorKeys.Length; i++)
			{
				array[i] = new GradientColorKey(Cfg.CombineRgb(colorKeys[i].color), colorKeys[i].time);
			}
			GradientAlphaKey[] alphaKeys = src.alphaKeys;
			GradientAlphaKey[] array2 = (GradientAlphaKey[])(object)new GradientAlphaKey[alphaKeys.Length];
			float alphaFactor = Cfg.AlphaFactor;
			for (int j = 0; j < alphaKeys.Length; j++)
			{
				array2[j] = new GradientAlphaKey(Mathf.Clamp01(alphaKeys[j].alpha * alphaFactor), alphaKeys[j].time);
			}
			Gradient val = new Gradient
			{
				mode = src.mode
			};
			val.SetKeys(array, array2);
			return val;
		}

		private static MinMaxGradient Copy(MinMaxGradient src)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected I4, but got Unknown
			//IL_0039: 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_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			ParticleSystemGradientMode mode = ((MinMaxGradient)(ref src)).mode;
			switch (mode - 1)
			{
			case 0:
			case 3:
			{
				MinMaxGradient result = default(MinMaxGradient);
				((MinMaxGradient)(ref result))..ctor(Copy(((MinMaxGradient)(ref src)).gradient));
				((MinMaxGradient)(ref result)).mode = ((MinMaxGradient)(ref src)).mode;
				return result;
			}
			case 2:
				return new MinMaxGradient(Copy(((MinMaxGradient)(ref src)).gradientMin), Copy(((MinMaxGradient)(ref src)).gradientMax));
			default:
				return src;
			}
		}

		private static Gradient Copy(Gradient src)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			if (src == null)
			{
				return null;
			}
			Gradient val = new Gradient
			{
				mode = src.mode
			};
			val.SetKeys(src.colorKeys, src.alphaKeys);
			return val;
		}

		private static int FindColorProp(Material mat)
		{
			string[] colorProps = ColorProps;
			for (int i = 0; i < colorProps.Length; i++)
			{
				int num = Shader.PropertyToID(colorProps[i]);
				if (mat.HasProperty(num))
				{
					return num;
				}
			}
			return -1;
		}

		public static void Clear()
		{
			Particles.Clear();
			DestroyMaterials(Decals);
			Decals.Clear();
			Pristine.Clear();
			Vfx = null;
		}

		private static void DestroyMaterials(IEnumerable<DecalTarget> targets)
		{
			foreach (DecalTarget target in targets)
			{
				if ((Object)(object)target.Material != (Object)null)
				{
					Object.Destroy((Object)(object)target.Material);
				}
			}
		}

		public static void LogEffects()
		{
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("---- BloodColor: what I found ----");
			stringBuilder.AppendLine($"Particles ({Particles.Count}):");
			foreach (ParticleTarget particle in Particles)
			{
				if (!((Object)(object)particle.System == (Object)null))
				{
					Material val = (Object.op_Implicit((Object)(object)particle.Renderer) ? ((Renderer)particle.Renderer).sharedMaterial : null);
					stringBuilder.AppendLine("  [" + particle.Owner + "] " + PathOf(((Component)particle.System).transform));
					stringBuilder.AppendLine($"      startColor : {((MinMaxGradient)(ref particle.Original)).mode} {DescribeStartColor(particle.Original)}");
					stringBuilder.AppendLine("      material   : " + (Object.op_Implicit((Object)(object)val) ? ((Object)val).name : "none"));
					stringBuilder.AppendLine("      shader     : " + ((Object.op_Implicit((Object)(object)val) && Object.op_Implicit((Object)(object)val.shader)) ? ((Object)val.shader).name : "none"));
					stringBuilder.AppendLine("      mat colour : " + MaterialColor(val));
				}
			}
			stringBuilder.AppendLine($"Decals ({Decals.Count}):");
			foreach (DecalTarget decal in Decals)
			{
				stringBuilder.AppendLine($"  [{decal.Name}] {decal.Projectors.Count} projectors");
				stringBuilder.AppendLine("      shader     : " + ((Object.op_Implicit((Object)(object)decal.Material) && Object.op_Implicit((Object)(object)decal.Material.shader)) ? ((Object)decal.Material.shader).name : "none"));
				stringBuilder.AppendLine("      colour     : " + ((decal.ColorProp >= 0) ? ((object)Unsafe.As<Color, Color>(ref decal.OriginalColor)/*cast due to .constrained prefix*/).ToString() : "no property found"));
				stringBuilder.AppendLine($"      fade       : {decal.OriginalFade}");
			}
			stringBuilder.AppendLine("VFX SmallBloodExplosion:");
			stringBuilder.AppendLine((Vfx == null) ? "      no colour property found" : ("      using '" + Vfx.Property + "'"));
			stringBuilder.Append(VfxProperties());
			Plugin.Log.LogInfo((object)stringBuilder.ToString());
		}

		private static string DescribeStartColor(MinMaxGradient g)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected I4, but got Unknown
			//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_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			ParticleSystemGradientMode mode = ((MinMaxGradient)(ref g)).mode;
			switch ((int)mode)
			{
			case 0:
				return ((object)((MinMaxGradient)(ref g)).color/*cast due to .constrained prefix*/).ToString();
			case 2:
				return $"{((MinMaxGradient)(ref g)).colorMin} .. {((MinMaxGradient)(ref g)).colorMax}";
			case 1:
			case 4:
			{
				Gradient gradient = ((MinMaxGradient)(ref g)).gradient;
				return $"{((gradient != null) ? gradient.colorKeys.Length : 0)} colour key(s)";
			}
			case 3:
			{
				Gradient gradientMin = ((MinMaxGradient)(ref g)).gradientMin;
				object arg = ((gradientMin != null) ? gradientMin.colorKeys.Length : 0);
				Gradient gradientMax = ((MinMaxGradient)(ref g)).gradientMax;
				return $"{arg} + {((gradientMax != null) ? gradientMax.colorKeys.Length : 0)} key(s)";
			}
			default:
				return string.Empty;
			}
		}

		private static string MaterialColor(Material mat)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)mat == (Object)null)
			{
				return "none";
			}
			string[] colorProps = ColorProps;
			foreach (string text in colorProps)
			{
				int num = Shader.PropertyToID(text);
				if (mat.HasProperty(num))
				{
					return $"{text} = {mat.GetColor(num)}";
				}
			}
			return "no known colour property";
		}

		private static string VfxProperties()
		{
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<string, VisualEffect> allVfx = VFXManager._allVfx;
			if (allVfx == null || !allVfx.TryGetValue("SmallBloodExplosion", out var value) || (Object)(object)value == (Object)null)
			{
				return "      (not in this scene)\n";
			}
			StringBuilder stringBuilder = new StringBuilder();
			VisualEffectAsset visualEffectAsset = value.visualEffectAsset;
			stringBuilder.AppendLine("      asset      : " + (((Object)(object)visualEffectAsset != (Object)null) ? ((Object)visualEffectAsset).name : "none"));
			if ((Object)(object)visualEffectAsset == (Object)null)
			{
				return stringBuilder.ToString();
			}
			List<VFXExposedProperty> list = new List<VFXExposedProperty>();
			try
			{
				visualEffectAsset.GetExposedProperties(list);
			}
			catch (Exception ex)
			{
				stringBuilder.AppendLine("      (couldn't read exposed properties: " + ex.Message + ")");
				return stringBuilder.ToString();
			}
			if (list.Count == 0)
			{
				stringBuilder.AppendLine("      exposes nothing at all - this effect can't be recoloured");
				return stringBuilder.ToString();
			}
			stringBuilder.AppendLine($"      exposes ({list.Count}):");
			foreach (VFXExposedProperty item in list)
			{
				stringBuilder.AppendLine("        " + item.name + " : " + item.type?.Name);
			}
			return stringBuilder.ToString();
		}

		private static string PathOf(Transform t)
		{
			StringBuilder stringBuilder = new StringBuilder(((Object)t).name);
			Transform parent = t.parent;
			while ((Object)(object)parent != (Object)null)
			{
				stringBuilder.Insert(0, ((Object)parent).name + "/");
				parent = parent.parent;
			}
			return stringBuilder.ToString();
		}
	}
	[HarmonyPatch(typeof(ParticleManager), "Awake")]
	internal static class ParticleManagerAwake
	{
		private static void Postfix()
		{
			Plugin.QueueRefresh();
		}
	}
	[HarmonyPatch(typeof(DecalManager), "Awake")]
	internal static class DecalManagerAwake
	{
		private static void Postfix()
		{
			Plugin.QueueRefresh();
		}
	}
	[HarmonyPatch(typeof(VFXManager), "Awake")]
	internal static class VfxManagerAwake
	{
		private static void Postfix()
		{
			Plugin.QueueRefresh();
		}
	}
	[HarmonyPatch(typeof(ParticleManager), "Play", new Type[]
	{
		typeof(string),
		typeof(Vector3),
		typeof(Vector3)
	})]
	internal static class ParticleManagerPlay
	{
		private static bool Prefix(string type)
		{
			if (!Plugin.BloodOff)
			{
				return true;
			}
			string[] particleNames = BloodTinter.ParticleNames;
			foreach (string b in particleNames)
			{
				if (string.Equals(type, b, StringComparison.Ordinal))
				{
					return false;
				}
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(DecalManager), "SpawnDecal")]
	internal static class DecalManagerSpawnDecal
	{
		private static bool Prefix(string decalName)
		{
			if (Plugin.BloodOff && decalName != null)
			{
				return !decalName.StartsWith("BloodDecal", StringComparison.Ordinal);
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(VFXManager), "Play", new Type[]
	{
		typeof(string),
		typeof(Vector3),
		typeof(Vector3)
	})]
	internal static class VfxManagerPlay
	{
		private static bool Prefix(string type)
		{
			if (Plugin.BloodOff)
			{
				return !string.Equals(type, "SmallBloodExplosion", StringComparison.Ordinal);
			}
			return true;
		}
	}
	[BepInPlugin("com.zoe.howtofish.bloodcolor", "BloodColor", "1.0.0")]
	public class Plugin : BaseUnityPlugin
	{
		public const string Guid = "com.zoe.howtofish.bloodcolor";

		public const string Name = "BloodColor";

		public const string Version = "1.0.0";

		internal static ManualLogSource Log;

		internal static BloodConfig Cfg;

		internal static bool BloodOff;

		private Harmony _harmony;

		private static bool _refreshQueued;

		private bool _loggedFailure;

		private void Awake()
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			Cfg = new BloodConfig(((BaseUnityPlugin)this).Config);
			BloodOff = !Cfg.EnableBlood.Value;
			Cfg.Changed += OnConfigChanged;
			try
			{
				_harmony = new Harmony("com.zoe.howtofish.bloodcolor");
				_harmony.PatchAll(typeof(Plugin).Assembly);
			}
			catch (Exception ex)
			{
				Log.LogError((object)("Couldn't apply patches, BloodColor is doing nothing this session. Probably a game update moved something, see Patches.cs.\n" + ex));
				return;
			}
			SceneManager.sceneLoaded += OnSceneLoaded;
			QueueRefresh();
			Log.LogInfo((object)string.Format("{0} {1} loaded. Colour {2}, mode {3}.", "BloodColor", "1.0.0", Cfg.Hex.Value, Cfg.Mode.Value));
		}

		private void OnDestroy()
		{
			SceneManager.sceneLoaded -= OnSceneLoaded;
			if (Cfg != null)
			{
				Cfg.Changed -= OnConfigChanged;
			}
			BloodTinter.Clear();
			Harmony harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}

		internal static void QueueRefresh()
		{
			_refreshQueued = true;
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			QueueRefresh();
		}

		private void Update()
		{
			if (!_refreshQueued)
			{
				return;
			}
			_refreshQueued = false;
			try
			{
				Refresh();
			}
			catch (Exception arg)
			{
				if (!_loggedFailure)
				{
					_loggedFailure = true;
					Log.LogError((object)$"Refresh failed, not going to report this again: {arg}");
				}
			}
		}

		private void Refresh()
		{
			int num = BloodTinter.FindParticles();
			int num2 = BloodTinter.FindDecals();
			int num3 = BloodTinter.FindVfx();
			if (num + num2 + num3 != 0)
			{
				BloodTinter.Apply();
				string arg = ((num3 > 0) ? $", {num3} vfx" : string.Empty);
				Log.LogInfo((object)$"Recoloured {num} particle systems, {num2} decal pools{arg}.");
				if (Cfg.LogEffects.Value)
				{
					BloodTinter.LogEffects();
				}
			}
		}

		private void OnConfigChanged()
		{
			BloodOff = !Cfg.EnableBlood.Value;
			try
			{
				BloodTinter.Apply();
				if (Cfg.LogEffects.Value)
				{
					BloodTinter.LogEffects();
				}
				Log.LogInfo((object)($"Config changed: {Cfg.Hex.Value}, {Cfg.Mode.Value}, opacity {Cfg.Opacity.Value}, " + string.Format("intensity {0}, blood {1}.", Cfg.Intensity.Value, Cfg.EnableBlood.Value ? "on" : "off")));
			}
			catch (Exception arg)
			{
				Log.LogError((object)$"Couldn't apply that config change: {arg}");
			}
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}