using System;
using System.Collections;
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 System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using PluginConfig.API;
using PluginConfig.API.Decorators;
using PluginConfig.API.Fields;
using UnityEngine;
using UnityEngine.Rendering;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("UltraBlood")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Recolors ULTRAKILL blood splatters and puddles to a custom color.")]
[assembly: AssemblyFileVersion("0.2.1.0")]
[assembly: AssemblyInformationalVersion("0.2.1+85b68089e57ba10d8fea52167845b88a2d6c1c17")]
[assembly: AssemblyProduct("UltraBlood")]
[assembly: AssemblyTitle("UltraBlood")]
[assembly: AssemblyVersion("0.2.1.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 UltraBlood
{
	internal static class BloodColorController
	{
		private const string BloodColorProperty = "_UltraBloodColor";

		private static Material _replacementComposite;

		private static Material _originalComposite;

		private static bool _activeLogged;

		private static bool _failureLogged;

		private static bool _renderPassLogged;

		private static bool _statusReported;

		private static string _lastDiagFingerprint;

		private const float RainbowCycleSpeed = 0.35f;

		public static bool PuddleRecolorActive { get; private set; }

		public static void Refresh()
		{
			if (TryGetManager(out var bsm))
			{
				ApplyToStainMaterials(bsm);
			}
		}

		public static void ApplyToStainMaterials(BloodsplatterManager bsm)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)bsm == (Object)null))
			{
				if (UltraBloodConfig.Enabled && UltraBloodConfig.RecolorPuddles)
				{
					ReplaceComposite(bsm, CurrentColor());
				}
				else
				{
					RestoreComposite(bsm);
				}
				if (UltraBloodConfig.DebugLogging)
				{
					LogStainMaterialsOnce(bsm);
				}
			}
		}

		public static void RestoreStainMaterials()
		{
			if (TryGetManager(out var bsm))
			{
				RestoreComposite(bsm);
			}
			if ((Object)(object)_replacementComposite != (Object)null)
			{
				Object.Destroy((Object)(object)_replacementComposite);
				_replacementComposite = null;
			}
		}

		public static void NoteCompositeRenderPass()
		{
			if (!_renderPassLogged && UltraBloodConfig.DebugLogging && TryGetManager(out var bsm) && !((Object)(object)bsm.bloodCompositeMaterial == (Object)null))
			{
				_renderPassLogged = true;
				Material bloodCompositeMaterial = bsm.bloodCompositeMaterial;
				bool flag = (Object)(object)_replacementComposite != (Object)null && bloodCompositeMaterial == _replacementComposite;
				string arg = (((Object)(object)bloodCompositeMaterial.shader != (Object)null) ? ((Object)bloodCompositeMaterial.shader).name : "<null>");
				Plugin.Log.LogInfo((object)$"[shader] composite render pass material id={((Object)bloodCompositeMaterial).GetInstanceID()} shader='{arg}' passIndex=1 isReplacement={flag}");
			}
		}

		private static Color CurrentColor()
		{
			//IL_0007: 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_0057: 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_0023: Unknown result type (might be due to invalid IL or missing references)
			if (UltraBloodConfig.SolidCyanTest)
			{
				return Color.cyan;
			}
			if (UltraBloodConfig.EnemyBloodColorMatch)
			{
				return (Color)(((??)BloodParticles.LastEnemyColor) ?? UltraBloodConfig.BloodColor);
			}
			if (UltraBloodConfig.RainbowBlood)
			{
				return Color.HSVToRGB(Mathf.Repeat(Time.time * 0.35f, 1f), 0.9f, 1f);
			}
			return UltraBloodConfig.BloodColor;
		}

		public static void TickDynamicColor()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: 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_0031: 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)
			if (PuddleRecolorActive && !((Object)(object)_replacementComposite == (Object)null))
			{
				Color val = CurrentColor();
				_replacementComposite.SetColor("_UltraBloodColor", new Color(val.r, val.g, val.b, UltraBloodConfig.PuddleOpacity));
			}
		}

		private static void ReplaceComposite(BloodsplatterManager bsm, Color color)
		{
			//IL_00a1: 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_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: 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_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Expected O, but got Unknown
			Shader compositeShader = ShaderBundle.CompositeShader;
			if ((Object)(object)compositeShader == (Object)null)
			{
				PuddleRecolorActive = false;
				if (!_failureLogged)
				{
					_failureLogged = true;
					Plugin.Log.LogError((object)($"[shader] puddle recoloring unavailable: {ShaderBundle.Status} ({ShaderBundle.StatusMessage}). " + "Running Unity " + Application.unityVersion + ". Leaving the vanilla composite in place."));
					ReportStatus($"Puddle recoloring unavailable ({ShaderBundle.Status}). See the log.", ok: false);
				}
				return;
			}
			if ((Object)(object)_replacementComposite == (Object)null)
			{
				_replacementComposite = new Material(compositeShader)
				{
					name = "UltraBlood_CompositeBlood"
				};
			}
			_replacementComposite.SetColor("_UltraBloodColor", new Color(color.r, color.g, color.b, UltraBloodConfig.PuddleOpacity));
			Material bloodCompositeMaterial = bsm.bloodCompositeMaterial;
			if ((Object)(object)bloodCompositeMaterial != (Object)(object)_replacementComposite)
			{
				if ((Object)(object)bloodCompositeMaterial != (Object)null)
				{
					_originalComposite = bloodCompositeMaterial;
				}
				bsm.bloodCompositeMaterial = _replacementComposite;
				if (!_activeLogged)
				{
					_activeLogged = true;
					Material bloodCompositeMaterial2 = bsm.bloodCompositeMaterial;
					Plugin.Log.LogInfo((object)$"[shader] manager id={((Object)bsm).GetInstanceID()}");
					Plugin.Log.LogInfo((object)string.Format("[shader] original composite id={0} name='{1}'", ((Object)(object)_originalComposite != (Object)null) ? ((Object)_originalComposite).GetInstanceID() : 0, ((Object)(object)_originalComposite != (Object)null) ? ((Object)_originalComposite).name : "null"));
					Plugin.Log.LogInfo((object)$"[shader] replacement composite id={((Object)_replacementComposite).GetInstanceID()} name='{((Object)_replacementComposite).name}' shader='{((Object)compositeShader).name}' passCount={compositeShader.passCount}");
					Plugin.Log.LogInfo((object)$"[shader] manager field material id={(((Object)(object)bloodCompositeMaterial2 != (Object)null) ? ((Object)bloodCompositeMaterial2).GetInstanceID() : 0)} referencesReplacement={bloodCompositeMaterial2 == _replacementComposite}");
				}
			}
			PuddleRecolorActive = true;
			ReportStatus("Puddle recoloring active.", ok: true);
		}

		private static void RestoreComposite(BloodsplatterManager bsm)
		{
			if ((Object)(object)_originalComposite != (Object)null && (Object)(object)bsm.bloodCompositeMaterial == (Object)(object)_replacementComposite)
			{
				bsm.bloodCompositeMaterial = _originalComposite;
			}
			PuddleRecolorActive = false;
		}

		private static void ReportStatus(string text, bool ok)
		{
			if (!_statusReported)
			{
				_statusReported = true;
				UltraBloodConfig.SetPuddleStatus(text, ok);
			}
		}

		private static void LogStainMaterialsOnce(BloodsplatterManager bsm)
		{
			//IL_0092: 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)
			string[] obj = new string[8]
			{
				((Object)bsm).GetInstanceID().ToString(),
				MaterialId(bsm.stainMat),
				MaterialId(bsm.bloodCompositeMaterial),
				PuddleRecolorActive ? "active" : "inactive",
				UltraBloodConfig.Enabled ? "on" : "off",
				UltraBloodConfig.RecolorPuddles ? "puddles" : "nopuddles",
				UltraBloodConfig.SolidCyanTest ? "cyan" : "color",
				null
			};
			Color val = CurrentColor();
			obj[7] = ((Color)(ref val)).ToString("F2");
			string text = string.Join("|", obj);
			if (!(text == _lastDiagFingerprint))
			{
				_lastDiagFingerprint = text;
				LogMaterial("stainMat", bsm.stainMat);
				LogMaterial("bloodCompositeMaterial", bsm.bloodCompositeMaterial);
			}
		}

		private static string MaterialId(Material mat)
		{
			if (!((Object)(object)mat == (Object)null))
			{
				return ((Object)mat).GetInstanceID().ToString();
			}
			return "null";
		}

		private static void LogMaterial(string label, Material mat)
		{
			//IL_0109: 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_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Expected I4, but got Unknown
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)mat == (Object)null)
			{
				Plugin.Log.LogInfo((object)("[diagnostics] " + label + ": <null material>"));
				return;
			}
			Shader shader = mat.shader;
			Plugin.Log.LogInfo((object)$"[diagnostics] === {label} === material='{((Object)mat).name}' id={((Object)mat).GetInstanceID()} renderQueue={mat.renderQueue}");
			if ((Object)(object)shader == (Object)null)
			{
				Plugin.Log.LogInfo((object)"[diagnostics] shader=<null>");
				return;
			}
			Plugin.Log.LogInfo((object)$"[diagnostics] shader='{((Object)shader).name}' id={((Object)shader).GetInstanceID()} passCount={shader.passCount}");
			string[] shaderKeywords = mat.shaderKeywords;
			Plugin.Log.LogInfo((object)("[diagnostics] enabledKeywords=[" + ((shaderKeywords != null && shaderKeywords.Length != 0) ? string.Join(", ", shaderKeywords) : "none") + "]"));
			int propertyCount = shader.GetPropertyCount();
			for (int i = 0; i < propertyCount; i++)
			{
				string propertyName = shader.GetPropertyName(i);
				ShaderPropertyType propertyType = shader.GetPropertyType(i);
				string arg;
				switch ((int)propertyType)
				{
				case 0:
				{
					Color color = mat.GetColor(propertyName);
					arg = ((Color)(ref color)).ToString("F3");
					break;
				}
				case 1:
				{
					Vector4 vector = mat.GetVector(propertyName);
					arg = ((Vector4)(ref vector)).ToString("F3");
					break;
				}
				case 2:
				case 3:
					arg = mat.GetFloat(propertyName).ToString("F3");
					break;
				case 4:
					arg = DescribeTexture(mat.GetTexture(propertyName));
					break;
				case 5:
					arg = mat.GetInt(propertyName).ToString();
					break;
				default:
					arg = "<unknown>";
					break;
				}
				Plugin.Log.LogInfo((object)$"[diagnostics]   {propertyName} <{propertyType}> = {arg}");
			}
		}

		private static string DescribeTexture(Texture texture)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)texture == (Object)null)
			{
				return "<none>";
			}
			Texture2D val = (Texture2D)(object)((texture is Texture2D) ? texture : null);
			string text = ((val != null) ? $" {val.format}" : string.Empty);
			return $"'{((Object)texture).name}' ({((object)texture).GetType().Name} {texture.width}x{texture.height}{text})";
		}

		private static bool TryGetManager(out BloodsplatterManager bsm)
		{
			bsm = null;
			try
			{
				return MonoSingleton<BloodsplatterManager>.TryGetInstance(ref bsm) && (Object)(object)bsm != (Object)null;
			}
			catch (Exception)
			{
				return false;
			}
		}
	}
	internal static class BloodParticles
	{
		private sealed class Snapshot
		{
			public ParticleSystem System;

			public MinMaxGradient StartColor;

			public bool LifetimeEnabled;

			public MinMaxGradient Lifetime;

			public bool SpeedEnabled;

			public MinMaxGradient Speed;

			public bool TrailsEnabled;

			public MinMaxGradient TrailLifetime;

			public MinMaxGradient TrailOverTrail;

			public ParticleSystemRenderer Renderer;

			public Material OriginalMaterial;

			public Material PrivateMaterial;

			public string TintProperty;

			public Color RainbowColor;

			public Color? EnemyColor;
		}

		private static readonly Dictionary<int, Snapshot> Snapshots = new Dictionary<int, Snapshot>();

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

		private static readonly Dictionary<int, EnemyIdentifier> BloodEnemies = new Dictionary<int, EnemyIdentifier>();

		private static readonly Dictionary<int, Color> EnemyColors = new Dictionary<int, Color>();

		private static readonly string[] TintProperties = new string[3] { "_Color", "_BaseColor", "_TintColor" };

		private static readonly Dictionary<EnemyType, Color> EnemyPalette = new Dictionary<EnemyType, Color>
		{
			{
				(EnemyType)3,
				new Color(0.72f, 0.58f, 0.42f)
			},
			{
				(EnemyType)13,
				new Color(0.8f, 0.64f, 0.6f)
			},
			{
				(EnemyType)14,
				new Color(0.76f, 0.32f, 0.34f)
			},
			{
				(EnemyType)15,
				new Color(0.44f, 0.52f, 0.3f)
			},
			{
				(EnemyType)36,
				new Color(0.7f, 0.66f, 0.62f)
			},
			{
				(EnemyType)5,
				new Color(0.82f, 0.84f, 0.9f)
			},
			{
				(EnemyType)1,
				new Color(0.55f, 0.58f, 0.62f)
			},
			{
				(EnemyType)6,
				new Color(0.9f, 0.55f, 0.15f)
			},
			{
				(EnemyType)12,
				new Color(0.8f, 0.45f, 0.15f)
			},
			{
				(EnemyType)7,
				new Color(0.75f, 0.16f, 0.16f)
			},
			{
				(EnemyType)8,
				new Color(0.22f, 0.46f, 0.85f)
			},
			{
				(EnemyType)22,
				new Color(0.22f, 0.46f, 0.85f)
			},
			{
				(EnemyType)20,
				new Color(0.72f, 0.5f, 0.24f)
			},
			{
				(EnemyType)31,
				new Color(0.88f, 0.86f, 0.82f)
			},
			{
				(EnemyType)33,
				new Color(0.46f, 0.49f, 0.53f)
			},
			{
				(EnemyType)34,
				new Color(0.4f, 0.43f, 0.47f)
			},
			{
				(EnemyType)35,
				new Color(0.5f, 0.53f, 0.57f)
			},
			{
				(EnemyType)0,
				new Color(0.85f, 0.84f, 0.8f)
			},
			{
				(EnemyType)2,
				new Color(0.66f, 0.26f, 0.26f)
			},
			{
				(EnemyType)4,
				new Color(0.8f, 0.68f, 0.42f)
			},
			{
				(EnemyType)9,
				new Color(0.96f, 0.82f, 0.32f)
			},
			{
				(EnemyType)10,
				new Color(0.26f, 0.26f, 0.3f)
			},
			{
				(EnemyType)23,
				new Color(0.55f, 0.4f, 0.28f)
			},
			{
				(EnemyType)24,
				new Color(0.5f, 0.36f, 0.25f)
			},
			{
				(EnemyType)21,
				new Color(0.9f, 0.75f, 0.3f)
			},
			{
				(EnemyType)11,
				new Color(0.6f, 0.58f, 0.55f)
			},
			{
				(EnemyType)18,
				new Color(0.82f, 0.8f, 0.76f)
			},
			{
				(EnemyType)16,
				new Color(0.92f, 0.86f, 0.62f)
			},
			{
				(EnemyType)28,
				new Color(0.8f, 0.22f, 0.22f)
			},
			{
				(EnemyType)19,
				new Color(0.7f, 0.46f, 0.42f)
			},
			{
				(EnemyType)29,
				new Color(0.8f, 0.76f, 0.72f)
			},
			{
				(EnemyType)17,
				new Color(0.78f, 0.66f, 0.6f)
			},
			{
				(EnemyType)30,
				new Color(0.78f, 0.66f, 0.6f)
			},
			{
				(EnemyType)26,
				new Color(0.7f, 0.74f, 0.78f)
			},
			{
				(EnemyType)27,
				new Color(0.35f, 0.45f, 0.55f)
			},
			{
				(EnemyType)32,
				new Color(0.5f, 0.5f, 0.52f)
			},
			{
				(EnemyType)38,
				new Color(0.9f, 0.78f, 0.35f)
			},
			{
				(EnemyType)41,
				new Color(0.22f, 0.22f, 0.26f)
			}
		};

		public static Color? LastEnemyColor { get; private set; }

		public static void NoteEnemy(Bloodsplatter splatter, EnemyIdentifier eid)
		{
			if (!((Object)(object)splatter == (Object)null))
			{
				int instanceID = ((Object)splatter).GetInstanceID();
				if ((Object)(object)eid != (Object)null)
				{
					BloodEnemies[instanceID] = eid;
				}
				else
				{
					BloodEnemies.Remove(instanceID);
				}
			}
		}

		public static void Register(Bloodsplatter splatter)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)splatter == (Object)null || !UltraBloodConfig.Enabled || !UltraBloodConfig.RecolorSplatters)
			{
				return;
			}
			GameObject gameObject = ((Component)splatter).gameObject;
			if ((Object)(object)gameObject == (Object)null || IsExcludedVariant(splatter.bloodSplatterType))
			{
				return;
			}
			Color? enemyColor = EnemyColorFor(splatter);
			HashSet<int> visited = new HashSet<int>();
			RegisterHierarchy(gameObject, visited, enemyColor);
			Plugin.RunDelayed(gameObject, delegate
			{
				if (!((Object)(object)splatter == (Object)null) && !((Object)(object)((Component)splatter).gameObject == (Object)null))
				{
					HashSet<int> visited2 = new HashSet<int>();
					RegisterHierarchy(((Component)splatter).gameObject, visited2, EnemyColorFor(splatter));
				}
			});
		}

		public static void ReapplyAll()
		{
			Prune();
			bool flag = UltraBloodConfig.Enabled && UltraBloodConfig.RecolorSplatters;
			foreach (Snapshot value in Snapshots.Values)
			{
				if (!((Object)(object)value.System == (Object)null))
				{
					if (flag)
					{
						ApplyColor(value);
					}
					else
					{
						Restore(value);
					}
				}
			}
		}

		public static void RestoreAll()
		{
			foreach (Snapshot value in Snapshots.Values)
			{
				if ((Object)(object)value.System != (Object)null)
				{
					Restore(value);
				}
			}
		}

		private static void RegisterHierarchy(GameObject root, HashSet<int> visited, Color? enemyColor)
		{
			ParticleSystem[] componentsInChildren = root.GetComponentsInChildren<ParticleSystem>(true);
			if (componentsInChildren != null)
			{
				ParticleSystem[] array = componentsInChildren;
				for (int i = 0; i < array.Length; i++)
				{
					RegisterSystem(array[i], visited, root, enemyColor);
				}
			}
		}

		private static void RegisterSystem(ParticleSystem ps, HashSet<int> visited, GameObject root, Color? enemyColor)
		{
			//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_005c: 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)
			if ((Object)(object)ps == (Object)null || !visited.Add(((Object)ps).GetInstanceID()))
			{
				return;
			}
			int instanceID = ((Object)ps).GetInstanceID();
			if (!Snapshots.TryGetValue(instanceID, out var value))
			{
				value = Capture(ps);
				Snapshots[instanceID] = value;
				LogOnce(ps, root);
			}
			value.EnemyColor = enemyColor;
			ApplyColor(value);
			SubEmittersModule subEmitters = ps.subEmitters;
			int num = SafeSubEmitterCount(subEmitters);
			for (int i = 0; i < num; i++)
			{
				ParticleSystem val = SafeGetSubEmitter(subEmitters, i);
				if ((Object)(object)val != (Object)null)
				{
					RegisterSystem(val, visited, root, enemyColor);
				}
			}
		}

		private static Snapshot Capture(ParticleSystem ps)
		{
			//IL_000d: 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_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//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_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_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: 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_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: 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_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			Snapshot snapshot = new Snapshot
			{
				System = ps,
				RainbowColor = RandomVividColor()
			};
			MainModule main = ps.main;
			snapshot.StartColor = ((MainModule)(ref main)).startColor;
			ColorOverLifetimeModule colorOverLifetime = ps.colorOverLifetime;
			snapshot.LifetimeEnabled = ((ColorOverLifetimeModule)(ref colorOverLifetime)).enabled;
			snapshot.Lifetime = ((ColorOverLifetimeModule)(ref colorOverLifetime)).color;
			ColorBySpeedModule colorBySpeed = ps.colorBySpeed;
			snapshot.SpeedEnabled = ((ColorBySpeedModule)(ref colorBySpeed)).enabled;
			snapshot.Speed = ((ColorBySpeedModule)(ref colorBySpeed)).color;
			TrailModule trails = ps.trails;
			snapshot.TrailsEnabled = ((TrailModule)(ref trails)).enabled;
			if (((TrailModule)(ref trails)).enabled)
			{
				snapshot.TrailLifetime = ((TrailModule)(ref trails)).colorOverLifetime;
				snapshot.TrailOverTrail = ((TrailModule)(ref trails)).colorOverTrail;
			}
			ParticleSystemRenderer component = ((Component)ps).GetComponent<ParticleSystemRenderer>();
			if ((Object)(object)component != (Object)null)
			{
				snapshot.Renderer = component;
				snapshot.OriginalMaterial = ((Renderer)component).sharedMaterial;
				snapshot.TintProperty = FindRedDominantTintProperty(((Renderer)component).sharedMaterial);
			}
			return snapshot;
		}

		private static void ApplyColor(Snapshot snap)
		{
			//IL_0012: 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_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: 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_0040: 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_0049: 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_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: 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_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_0090: 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_00a3: 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_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			ParticleSystem system = snap.System;
			if ((Object)(object)system == (Object)null)
			{
				return;
			}
			Color target = TargetFor(snap);
			MainModule main = system.main;
			((MainModule)(ref main)).startColor = Recolor(snap.StartColor, target);
			if (snap.LifetimeEnabled)
			{
				ColorOverLifetimeModule colorOverLifetime = system.colorOverLifetime;
				((ColorOverLifetimeModule)(ref colorOverLifetime)).color = Recolor(snap.Lifetime, target);
			}
			if (snap.SpeedEnabled)
			{
				ColorBySpeedModule colorBySpeed = system.colorBySpeed;
				((ColorBySpeedModule)(ref colorBySpeed)).color = Recolor(snap.Speed, target);
			}
			if (snap.TrailsEnabled)
			{
				TrailModule trails = system.trails;
				((TrailModule)(ref trails)).colorOverLifetime = Recolor(snap.TrailLifetime, target);
				((TrailModule)(ref trails)).colorOverTrail = Recolor(snap.TrailOverTrail, target);
			}
			if ((Object)(object)snap.Renderer != (Object)null && snap.TintProperty != null)
			{
				EnsurePrivateMaterial(snap);
				if ((Object)(object)snap.PrivateMaterial != (Object)null && snap.PrivateMaterial.HasProperty(snap.TintProperty))
				{
					Color val = (((Object)(object)snap.OriginalMaterial != (Object)null && snap.OriginalMaterial.HasProperty(snap.TintProperty)) ? snap.OriginalMaterial.GetColor(snap.TintProperty) : Color.white);
					snap.PrivateMaterial.SetColor(snap.TintProperty, new Color(1f, 1f, 1f, val.a));
				}
			}
		}

		private static void Restore(Snapshot snap)
		{
			//IL_0012: 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_001b: 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_0037: 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_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			ParticleSystem system = snap.System;
			if (!((Object)(object)system == (Object)null))
			{
				MainModule main = system.main;
				((MainModule)(ref main)).startColor = snap.StartColor;
				if (snap.LifetimeEnabled)
				{
					ColorOverLifetimeModule colorOverLifetime = system.colorOverLifetime;
					((ColorOverLifetimeModule)(ref colorOverLifetime)).color = snap.Lifetime;
				}
				if (snap.SpeedEnabled)
				{
					ColorBySpeedModule colorBySpeed = system.colorBySpeed;
					((ColorBySpeedModule)(ref colorBySpeed)).color = snap.Speed;
				}
				if (snap.TrailsEnabled)
				{
					TrailModule trails = system.trails;
					((TrailModule)(ref trails)).colorOverLifetime = snap.TrailLifetime;
					((TrailModule)(ref trails)).colorOverTrail = snap.TrailOverTrail;
				}
				if ((Object)(object)snap.Renderer != (Object)null && (Object)(object)snap.OriginalMaterial != (Object)null)
				{
					((Renderer)snap.Renderer).sharedMaterial = snap.OriginalMaterial;
				}
			}
		}

		private static void EnsurePrivateMaterial(Snapshot snap)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			if (!((Object)(object)snap.PrivateMaterial != (Object)null) && !((Object)(object)snap.Renderer == (Object)null) && !((Object)(object)snap.OriginalMaterial == (Object)null))
			{
				snap.PrivateMaterial = new Material(snap.OriginalMaterial)
				{
					name = ((Object)snap.OriginalMaterial).name + " (UltraBlood)"
				};
				((Renderer)snap.Renderer).sharedMaterial = snap.PrivateMaterial;
			}
		}

		private static Color TargetFor(Snapshot snap)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: 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_002c: 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)
			if (UltraBloodConfig.SolidCyanParticles)
			{
				return Color.cyan;
			}
			if (UltraBloodConfig.EnemyBloodColorMatch)
			{
				return (Color)(((??)snap.EnemyColor) ?? OpaqueBloodColor());
			}
			if (UltraBloodConfig.RainbowBlood)
			{
				return snap.RainbowColor;
			}
			return OpaqueBloodColor();
		}

		private static Color OpaqueBloodColor()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: 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_000c: 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_001d: Unknown result type (might be due to invalid IL or missing references)
			Color bloodColor = UltraBloodConfig.BloodColor;
			return new Color(bloodColor.r, bloodColor.g, bloodColor.b, 1f);
		}

		private static Color? EnemyColorFor(Bloodsplatter splatter)
		{
			//IL_0048: 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)
			if (!UltraBloodConfig.EnemyBloodColorMatch)
			{
				return null;
			}
			if (BloodEnemies.TryGetValue(((Object)splatter).GetInstanceID(), out var value) && (Object)(object)value != (Object)null)
			{
				Color? val = SampleEnemyColor(value);
				LastEnemyColor = (Color)(((??)val) ?? OpaqueBloodColor());
				return val;
			}
			return null;
		}

		private static Color? SampleEnemyColor(EnemyIdentifier eid)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			int instanceID = ((Object)eid).GetInstanceID();
			if (EnemyColors.TryGetValue(instanceID, out var value))
			{
				return value;
			}
			Color? result = ComputeEnemyColor(eid);
			if (result.HasValue)
			{
				EnemyColors[instanceID] = result.Value;
			}
			return result;
		}

		private static Color? ComputeEnemyColor(EnemyIdentifier eid)
		{
			//IL_0006: 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_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (EnemyPalette.TryGetValue(eid.enemyType, out var value))
				{
					return new Color(value.r, value.g, value.b, 1f);
				}
			}
			catch
			{
			}
			return null;
		}

		private static Color RandomVividColor()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			return Color.HSVToRGB(Random.value, Random.Range(0.7f, 1f), Random.Range(0.85f, 1f));
		}

		private static MinMaxGradient Recolor(MinMaxGradient original, Color target)
		{
			//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_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_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: 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_0042: 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_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: 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_0074: 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_0087: 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)
			//IL_00a9: 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)
			ParticleSystemGradientMode mode = ((MinMaxGradient)(ref original)).mode;
			switch ((int)mode)
			{
			case 0:
				return new MinMaxGradient(RecolorSourceColor(((MinMaxGradient)(ref original)).color, target));
			case 2:
				return new MinMaxGradient(RecolorSourceColor(((MinMaxGradient)(ref original)).colorMin, target), RecolorSourceColor(((MinMaxGradient)(ref original)).colorMax, target));
			case 1:
				return new MinMaxGradient(RecolorGradientObject(((MinMaxGradient)(ref original)).gradient, target));
			case 3:
				return new MinMaxGradient(RecolorGradientObject(((MinMaxGradient)(ref original)).gradientMin, target), RecolorGradientObject(((MinMaxGradient)(ref original)).gradientMax, target));
			case 4:
			{
				MinMaxGradient result = default(MinMaxGradient);
				((MinMaxGradient)(ref result))..ctor(RecolorGradientObject(((MinMaxGradient)(ref original)).gradient, target));
				((MinMaxGradient)(ref result)).mode = (ParticleSystemGradientMode)4;
				return result;
			}
			default:
				return original;
			}
		}

		private static Gradient RecolorGradientObject(Gradient source, Color target)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: 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)
			//IL_0029: 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_004a: 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_0057: Expected O, but got Unknown
			if (source == null)
			{
				return null;
			}
			GradientColorKey[] colorKeys = source.colorKeys;
			for (int i = 0; i < colorKeys.Length; i++)
			{
				colorKeys[i].color = RecolorSourceColor(colorKeys[i].color, target);
			}
			Gradient val = new Gradient();
			val.SetKeys(colorKeys, source.alphaKeys);
			val.mode = source.mode;
			return val;
		}

		private static Color RecolorSourceColor(Color source, Color target)
		{
			//IL_0000: 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_000c: 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_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: 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)
			float num = Mathf.Max(source.r, Mathf.Max(source.g, source.b));
			return new Color(target.r * num, target.g * num, target.b * num, source.a);
		}

		private static bool IsExcludedVariant(BSType type)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			//IL_0004: 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_000a: Invalid comparison between Unknown and I4
			if ((int)type != 7 && (int)type != 8)
			{
				return (int)type == 6;
			}
			return true;
		}

		private static string FindRedDominantTintProperty(Material material)
		{
			//IL_0024: 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_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: 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_004b: 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)
			if ((Object)(object)material == (Object)null)
			{
				return null;
			}
			string[] tintProperties = TintProperties;
			foreach (string text in tintProperties)
			{
				if (material.HasProperty(text))
				{
					Color color = material.GetColor(text);
					if (color.r > 0.25f && color.r > color.g * 1.5f && color.r > color.b * 1.5f)
					{
						return text;
					}
				}
			}
			return null;
		}

		private static void Prune()
		{
			if (Snapshots.Count == 0)
			{
				return;
			}
			List<int> list = new List<int>();
			foreach (KeyValuePair<int, Snapshot> snapshot in Snapshots)
			{
				if ((Object)(object)snapshot.Value.System == (Object)null)
				{
					list.Add(snapshot.Key);
				}
			}
			foreach (int item in list)
			{
				Snapshots.Remove(item);
			}
		}

		private static void LogOnce(ParticleSystem ps, GameObject root)
		{
			//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_00b1: 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_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			if (UltraBloodConfig.DebugLogging)
			{
				ParticleSystemRenderer component = ((Component)ps).GetComponent<ParticleSystemRenderer>();
				Material val = (((Object)(object)component != (Object)null) ? ((Renderer)component).sharedMaterial : null);
				Shader val2 = (((Object)(object)val != (Object)null) ? val.shader : null);
				MainModule main = ps.main;
				string text = HierarchyPath(((Component)ps).transform, root.transform);
				string item = string.Join("|", ((Object)root).name, text, ((Object)(object)val != (Object)null) ? ((Object)val).name : "no-mat", ((Object)(object)val2 != (Object)null) ? ((Object)val2).name : "no-shader");
				if (LoggedFingerprints.Add(item))
				{
					ColorOverLifetimeModule colorOverLifetime = ps.colorOverLifetime;
					ColorBySpeedModule colorBySpeed = ps.colorBySpeed;
					TrailModule trails = ps.trails;
					ManualLogSource log = Plugin.Log;
					string[] obj = new string[11]
					{
						$"[particles] root='{((Object)root).name}' path='{text}' ps='{((Object)ps).name}' id={((Object)ps).GetInstanceID()} ",
						null,
						null,
						null,
						null,
						null,
						null,
						null,
						null,
						null,
						null
					};
					object[] array = new object[4];
					MinMaxGradient startColor = ((MainModule)(ref main)).startColor;
					array[0] = ((MinMaxGradient)(ref startColor)).mode;
					array[1] = ((ColorOverLifetimeModule)(ref colorOverLifetime)).enabled;
					array[2] = ((ColorBySpeedModule)(ref colorBySpeed)).enabled;
					array[3] = ((TrailModule)(ref trails)).enabled;
					obj[1] = string.Format("startMode={0} colorOverLifetime={1} colorBySpeed={2} trails={3} ", array);
					obj[2] = "renderMode=";
					obj[3] = (((Object)(object)component != (Object)null) ? ((object)component.renderMode/*cast due to .constrained prefix*/).ToString() : "n/a");
					obj[4] = " material='";
					obj[5] = (((Object)(object)val != (Object)null) ? ((Object)val).name : "null");
					obj[6] = "' shader='";
					obj[7] = (((Object)(object)val2 != (Object)null) ? ((Object)val2).name : "null");
					obj[8] = "' redTintProperty='";
					obj[9] = FindRedDominantTintProperty(val) ?? "none";
					obj[10] = "'";
					log.LogInfo((object)string.Concat(obj));
				}
			}
		}

		private static string HierarchyPath(Transform node, Transform root)
		{
			if ((Object)(object)node == (Object)(object)root || (Object)(object)node == (Object)null)
			{
				if (!((Object)(object)node != (Object)null))
				{
					return "?";
				}
				return ((Object)node).name;
			}
			List<string> list = new List<string>();
			Transform val = node;
			int num = 0;
			while ((Object)(object)val != (Object)null && (Object)(object)val != (Object)(object)root && num++ < 32)
			{
				list.Insert(0, ((Object)val).name);
				val = val.parent;
			}
			list.Insert(0, ((Object)root).name);
			return string.Join("/", list);
		}

		private static int SafeSubEmitterCount(SubEmittersModule sub)
		{
			try
			{
				return ((SubEmittersModule)(ref sub)).enabled ? ((SubEmittersModule)(ref sub)).subEmittersCount : 0;
			}
			catch
			{
				return 0;
			}
		}

		private static ParticleSystem SafeGetSubEmitter(SubEmittersModule sub, int index)
		{
			try
			{
				return ((SubEmittersModule)(ref sub)).GetSubEmitterSystem(index);
			}
			catch
			{
				return null;
			}
		}
	}
	[HarmonyPatch]
	internal static class BloodPatches
	{
		[HarmonyPatch(typeof(BloodsplatterManager), "Start")]
		[HarmonyPostfix]
		private static void BloodsplatterManager_Start_Postfix(BloodsplatterManager __instance)
		{
			try
			{
				BloodColorController.ApplyToStainMaterials(__instance);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Failed to recolor bloodstain materials: " + ex.GetType().Name + ": " + ex.Message));
			}
		}

		[HarmonyPatch(typeof(Bloodsplatter), "OnEnable")]
		[HarmonyPrefix]
		private static void Bloodsplatter_OnEnable_Prefix(Bloodsplatter __instance)
		{
			try
			{
				BloodParticles.Register(__instance);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Failed to recolor blood splatter: " + ex.GetType().Name + ": " + ex.Message));
			}
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPostfix]
		private static void Bloodsplatter_set_eid_Postfix(Bloodsplatter __instance, EnemyIdentifier value)
		{
			try
			{
				BloodParticles.NoteEnemy(__instance, value);
			}
			catch (Exception)
			{
			}
		}

		[HarmonyPatch(typeof(PostProcessV2_Handler), "OnPreRenderCallback")]
		[HarmonyPostfix]
		private static void PostProcessV2_Handler_OnPreRenderCallback_Postfix()
		{
			try
			{
				BloodColorController.NoteCompositeRenderPass();
			}
			catch (Exception)
			{
			}
		}
	}
	internal enum BundleCompatibilityResult
	{
		NotAttempted,
		FileMissing,
		Loaded,
		LoadReturnedNull,
		LoadThrew,
		AlreadyLoaded
	}
	internal static class CompatibilityTest
	{
		private struct BundleRow
		{
			public string Name;

			public string Path;

			public bool IsSbp;

			public bool IsGame;

			public bool FileExists;

			public long Length;

			public string Sha256;

			public BundleCompatibilityResult Result;

			public string[] AssetNames;

			public bool TextLoaded;

			public string ShaderName;

			public bool ShaderSupported;

			public int PassCount;

			public string UnityError;
		}

		private const string TestsFolderName = "CompatibilityTests";

		private const string CompositeShaderName = "UltraBlood/CompositeBloodTint";

		private static bool _ran;

		private static ManualLogSource _log;

		public static string Summary { get; private set; } = "not run";

		public static bool AnySbpLoaded { get; private set; }

		public static bool SbpCompositeShaderValid { get; private set; }

		public static void RunOnce(ManualLogSource logger, string pluginDirectory)
		{
			if (!_ran)
			{
				_ran = true;
				_log = logger ?? Plugin.Log;
				_log.LogInfo((object)"[compat] CompatibilityTest entry reached.");
				try
				{
					Run(pluginDirectory);
				}
				catch (Exception ex)
				{
					Summary = "error: " + ex.GetType().Name;
					_log.LogError((object)("[compat] compatibility test crashed: " + ex));
				}
				UltraBloodConfig.SetCompatStatus("Compatibility: " + Summary, AnySbpLoaded);
			}
		}

		private static void Run(string pluginDirectory)
		{
			string text = SafeAssemblyLocation();
			string text2 = ((!string.IsNullOrEmpty(pluginDirectory)) ? pluginDirectory : SafeDirectoryName(text));
			string text3 = (string.IsNullOrEmpty(text2) ? null : Path.Combine(text2, "CompatibilityTests"));
			_log.LogInfo((object)("[compat] current working directory: " + SafeCwd()));
			_log.LogInfo((object)("[compat] plugin assembly location: " + (text ?? "<unknown>")));
			_log.LogInfo((object)("[compat] plugin directory: " + (text2 ?? "<unknown>")));
			_log.LogInfo((object)("[compat] expected CompatibilityTests directory: " + (text3 ?? "<unknown>")));
			if (text3 == null)
			{
				Summary = "plugin directory could not be resolved";
				_log.LogWarning((object)"[compat] plugin directory could not be resolved; matrix not run");
				return;
			}
			bool flag = Directory.Exists(text3);
			_log.LogInfo((object)("[compat] directory exists: " + flag));
			if (!flag)
			{
				Summary = "CompatibilityTests directory missing";
				_log.LogWarning((object)("[compat] CompatibilityTests directory missing: " + text3));
				return;
			}
			string[] array = Directory.GetFiles(text3, "*.bundle", SearchOption.TopDirectoryOnly).OrderBy<string, string>(Path.GetFileName, StringComparer.OrdinalIgnoreCase).ToArray();
			_log.LogInfo((object)("[compat] number of files found: " + array.Length));
			string[] array2 = array;
			foreach (string path in array2)
			{
				_log.LogInfo((object)("[compat] discovered: " + Path.GetFileName(path)));
			}
			List<BundleRow> list = new List<BundleRow>();
			try
			{
				array2 = array;
				foreach (string path2 in array2)
				{
					list.Add(TestBundle(Path.GetFileName(path2), path2, isGame: false, unloadAllLoadedObjects: true));
				}
				BundleRow? bundleRow = TryGameControlRow();
				if (bundleRow.HasValue)
				{
					list.Add(bundleRow.Value);
				}
			}
			finally
			{
				PrintTable(list);
			}
			int legacyTotal = list.Count((BundleRow r) => !r.IsSbp && !r.IsGame);
			int legacyLoaded = list.Count((BundleRow r) => !r.IsSbp && !r.IsGame && r.Result == BundleCompatibilityResult.Loaded);
			int sbpTotal = list.Count((BundleRow r) => r.IsSbp);
			int num = list.Count((BundleRow r) => r.IsSbp && r.Result == BundleCompatibilityResult.Loaded);
			AnySbpLoaded = num > 0;
			SbpCompositeShaderValid = list.Any((BundleRow r) => r.IsSbp && r.ShaderName == "UltraBlood/CompositeBloodTint" && r.ShaderSupported && r.PassCount >= 2);
			LogResidentBundles();
			Summary = BuildSummary(legacyLoaded, legacyTotal, num, sbpTotal);
			_log.LogInfo((object)("[compat] summary: " + Summary));
		}

		private static string BuildSummary(int legacyLoaded, int legacyTotal, int sbpLoaded, int sbpTotal)
		{
			string text = $"legacy {legacyLoaded}/{legacyTotal} loaded";
			string text2 = $"SBP {sbpLoaded}/{sbpTotal} loaded";
			string text3 = (SbpCompositeShaderValid ? "SBP composite shader valid (passes>=2)" : (AnySbpLoaded ? "SBP composite shader NOT validated" : "no SBP bundle loaded"));
			return text + ", " + text2 + ", " + text3;
		}

		private static BundleRow? TryGameControlRow()
		{
			try
			{
				string path = Path.Combine(Application.dataPath, "StreamingAssets", "aa", "StandaloneWindows64");
				if (!Directory.Exists(path))
				{
					_log.LogInfo((object)"[compat] game bundle control: Addressables folder not found, skipped");
					return null;
				}
				string text = (from f in Directory.GetFiles(path, "*.bundle", SearchOption.AllDirectories)
					orderby new FileInfo(f).Length
					select f).FirstOrDefault();
				if (text == null)
				{
					_log.LogInfo((object)"[compat] game bundle control: no game *.bundle found, skipped");
					return null;
				}
				return TestBundle("GAME:" + Path.GetFileName(text), text, isGame: true, unloadAllLoadedObjects: false);
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[compat] game bundle control failed: " + ex.Message));
				return null;
			}
		}

		private static BundleRow TestBundle(string label, string path, bool isGame, bool unloadAllLoadedObjects)
		{
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Expected O, but got Unknown
			BundleRow bundleRow = new BundleRow
			{
				Name = label,
				Path = path,
				IsGame = isGame,
				IsSbp = label.StartsWith("sbp-", StringComparison.OrdinalIgnoreCase),
				Result = BundleCompatibilityResult.NotAttempted,
				Sha256 = "n/a",
				ShaderName = "-",
				PassCount = -1
			};
			bundleRow.FileExists = File.Exists(path);
			if (!bundleRow.FileExists)
			{
				bundleRow.Result = BundleCompatibilityResult.FileMissing;
				LogRowDetail(bundleRow);
				return bundleRow;
			}
			bundleRow.Length = new FileInfo(path).Length;
			if (!isGame)
			{
				bundleRow.Sha256 = Sha256File(path);
			}
			string captured = null;
			LogCallback val = (LogCallback)delegate(string condition, string stackTrace, LogType type)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				//IL_0005: Invalid comparison between Unknown and I4
				if (((int)type == 0 || (int)type == 4) && condition != null && condition.IndexOf("AssetBundle", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					captured = condition.Trim();
				}
			};
			AssetBundle val2 = null;
			Application.logMessageReceived += val;
			try
			{
				val2 = AssetBundle.LoadFromFile(path);
			}
			catch (Exception ex)
			{
				bundleRow.UnityError = ex.Message.Trim();
				bundleRow.Result = ((ex.Message.IndexOf("already loaded", StringComparison.OrdinalIgnoreCase) >= 0) ? BundleCompatibilityResult.AlreadyLoaded : BundleCompatibilityResult.LoadThrew);
				LogRowDetail(bundleRow);
				return bundleRow;
			}
			finally
			{
				Application.logMessageReceived -= val;
			}
			if ((Object)(object)val2 == (Object)null)
			{
				bundleRow.Result = BundleCompatibilityResult.LoadReturnedNull;
				bundleRow.UnityError = captured;
				LogRowDetail(bundleRow);
				return bundleRow;
			}
			bundleRow.Result = BundleCompatibilityResult.Loaded;
			try
			{
				bundleRow.AssetNames = val2.GetAllAssetNames();
				TextAsset[] array = val2.LoadAllAssets<TextAsset>();
				bundleRow.TextLoaded = array != null && array.Length != 0;
				Shader val3 = val2.LoadAsset<Shader>("UltraBlood/CompositeBloodTint");
				if ((Object)(object)val3 == (Object)null)
				{
					Shader[] array2 = val2.LoadAllAssets<Shader>();
					val3 = ((array2 != null && array2.Length != 0) ? array2[0] : null);
				}
				if ((Object)(object)val3 != (Object)null)
				{
					bundleRow.ShaderName = ((Object)val3).name;
					bundleRow.ShaderSupported = val3.isSupported;
					bundleRow.PassCount = val3.passCount;
				}
			}
			catch (Exception ex2)
			{
				_log.LogWarning((object)("[compat] " + label + " inspection failed: " + ex2.GetType().Name + ": " + ex2.Message));
			}
			val2.Unload(unloadAllLoadedObjects);
			LogRowDetail(bundleRow);
			return bundleRow;
		}

		private static void LogRowDetail(BundleRow row)
		{
			string arg = ((row.AssetNames != null) ? string.Join(", ", row.AssetNames) : "-");
			_log.LogInfo((object)($"[compat]   {row.Name}: exists={row.FileExists} length={row.Length} sha256={row.Sha256} " + $"result={row.Result} assets=[{arg}] text={YesNo(row.TextLoaded, row.Result)} " + "shader='" + row.ShaderName + "' supported=" + SupportedText(row) + " passes=" + PassText(row) + (string.IsNullOrEmpty(row.UnityError) ? string.Empty : (" error='" + row.UnityError + "'"))));
		}

		private static void PrintTable(List<BundleRow> rows)
		{
			_log.LogInfo((object)"[compat] === matrix ===");
			_log.LogInfo((object)string.Format("[compat] {0,-38} {1,-17} {2,-5} {3,-32} {4,-9} {5}", "Bundle", "Load", "Text", "Shader", "Supported", "Passes"));
			foreach (BundleRow row in rows)
			{
				_log.LogInfo((object)$"[compat] {Trim(row.Name, 38),-38} {row.Result,-17} {YesNo(row.TextLoaded, row.Result),-5} {Trim(row.ShaderName, 32),-32} {SupportedText(row),-9} {PassText(row)}");
			}
			_log.LogInfo((object)"[compat] === end matrix ===");
		}

		private static void LogResidentBundles()
		{
			try
			{
				AssetBundle[] array = AssetBundle.GetAllLoadedAssetBundles().ToArray();
				_log.LogInfo((object)$"[compat] GetAllLoadedAssetBundles(): {array.Length} resident");
				foreach (AssetBundle item in array.Take(12))
				{
					_log.LogInfo((object)("[compat]   resident: " + SafeName(item)));
				}
				if (array.Length > 12)
				{
					_log.LogInfo((object)$"[compat]   ... and {array.Length - 12} more");
				}
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[compat] GetAllLoadedAssetBundles failed: " + ex.Message));
			}
		}

		private static string YesNo(bool value, BundleCompatibilityResult result)
		{
			if (result != BundleCompatibilityResult.Loaded)
			{
				return "-";
			}
			if (!value)
			{
				return "N";
			}
			return "Y";
		}

		private static string SupportedText(BundleRow row)
		{
			if (row.Result != BundleCompatibilityResult.Loaded || row.PassCount < 0)
			{
				return "-";
			}
			if (!row.ShaderSupported)
			{
				return "N";
			}
			return "Y";
		}

		private static string PassText(BundleRow row)
		{
			if (row.Result != BundleCompatibilityResult.Loaded || row.PassCount < 0)
			{
				return "-";
			}
			return row.PassCount.ToString();
		}

		private static string Trim(string value, int max)
		{
			if (string.IsNullOrEmpty(value))
			{
				return string.Empty;
			}
			if (value.Length > max)
			{
				return value.Substring(0, max - 1) + "~";
			}
			return value;
		}

		private static string SafeName(AssetBundle bundle)
		{
			try
			{
				return ((Object)(object)bundle != (Object)null) ? ((Object)bundle).name : "<null>";
			}
			catch
			{
				return "<unavailable>";
			}
		}

		private static string SafeCwd()
		{
			try
			{
				return Directory.GetCurrentDirectory();
			}
			catch
			{
				return "<unavailable>";
			}
		}

		private static string SafeAssemblyLocation()
		{
			try
			{
				return Assembly.GetExecutingAssembly().Location;
			}
			catch
			{
				return null;
			}
		}

		private static string SafeDirectoryName(string path)
		{
			try
			{
				return string.IsNullOrEmpty(path) ? null : Path.GetDirectoryName(path);
			}
			catch
			{
				return null;
			}
		}

		private static string Sha256File(string path)
		{
			try
			{
				using FileStream inputStream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete);
				using SHA256 sHA = SHA256.Create();
				byte[] array = sHA.ComputeHash(inputStream);
				StringBuilder stringBuilder = new StringBuilder(array.Length * 2);
				byte[] array2 = array;
				foreach (byte b in array2)
				{
					stringBuilder.Append(b.ToString("X2"));
				}
				return stringBuilder.ToString();
			}
			catch
			{
				return "n/a";
			}
		}
	}
	[BepInPlugin("ultrablood.kiyroprower.ultrakill", "UltraBlood", "0.2.1")]
	[BepInProcess("ULTRAKILL.exe")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		public const string Guid = "ultrablood.kiyroprower.ultrakill";

		public const string Version = "0.2.1";

		public const string PluginConfiguratorGuid = "com.eternalUnion.pluginConfigurator";

		internal static ManualLogSource Log;

		internal static Plugin Instance;

		private Harmony _harmony;

		private void Awake()
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			Instance = this;
			LogRuntimeEnvironment();
			UltraBloodConfig.Initialize(((BaseUnityPlugin)this).Logger);
			string pluginDirectory = GetPluginDirectory();
			try
			{
				CompatibilityTest.RunOnce(((BaseUnityPlugin)this).Logger, pluginDirectory);
			}
			catch (Exception arg)
			{
				Log.LogError((object)$"[compat] Compatibility test crashed: {arg}");
			}
			_harmony = new Harmony("ultrablood.kiyroprower.ultrakill");
			_harmony.PatchAll(typeof(BloodPatches));
			Log.LogInfo((object)("UltraBlood loaded (ultrablood.kiyroprower.ultrakill). Recoloring is " + (UltraBloodConfig.Enabled ? "on" : "off") + "."));
		}

		private static void LogRuntimeEnvironment()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			Log.LogInfo((object)($"[runtime] Unity={Application.unityVersion}, Platform={Application.platform}, " + "Product=" + Application.productName + ", GameVersion=" + Application.version + ", " + $"ProcessBits={IntPtr.Size * 8}"));
			Log.LogInfo((object)($"[runtime] OS={SystemInfo.operatingSystem}, GraphicsAPI={SystemInfo.graphicsDeviceType}, " + "GPU=" + SystemInfo.graphicsDeviceName + ", GfxVersion=" + SystemInfo.graphicsDeviceVersion + ", " + $"ShaderLevel={SystemInfo.graphicsShaderLevel}, Instancing={SystemInfo.supportsInstancing}"));
			LogHostBinary();
		}

		private static void LogHostBinary()
		{
			try
			{
				string text = Directory.GetParent(Application.dataPath)?.FullName;
				if (text != null)
				{
					string text2 = Path.Combine(text, "UnityPlayer.dll");
					if (!File.Exists(text2))
					{
						Log.LogInfo((object)"[runtime] UnityPlayer.dll not found next to the game");
						return;
					}
					FileVersionInfo versionInfo = FileVersionInfo.GetVersionInfo(text2);
					string text3 = Sha256File(text2);
					Log.LogInfo((object)("[runtime] UnityPlayer.dll ProductVersion=" + versionInfo.ProductVersion + ", FileVersion=" + versionInfo.FileVersion + ", sha256=" + text3));
				}
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("[runtime] UnityPlayer.dll inspection failed: " + ex.GetType().Name + ": " + ex.Message));
			}
		}

		private static string Sha256File(string path)
		{
			using FileStream inputStream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete);
			using SHA256 sHA = SHA256.Create();
			byte[] array = sHA.ComputeHash(inputStream);
			StringBuilder stringBuilder = new StringBuilder(array.Length * 2);
			byte[] array2 = array;
			foreach (byte b in array2)
			{
				stringBuilder.Append(b.ToString("X2"));
			}
			return stringBuilder.ToString();
		}

		private static string GetPluginDirectory()
		{
			try
			{
				return Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
			}
			catch
			{
				return null;
			}
		}

		internal static void RunDelayed(GameObject target, Action action)
		{
			if (!((Object)(object)Instance == (Object)null) && !((Object)(object)target == (Object)null) && action != null)
			{
				((MonoBehaviour)Instance).StartCoroutine(DelayedRoutine(target, action));
			}
		}

		private static IEnumerator DelayedRoutine(GameObject target, Action action)
		{
			yield return null;
			yield return (object)new WaitForSeconds(0.1f);
			if ((Object)(object)target == (Object)null)
			{
				yield break;
			}
			try
			{
				action();
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("[particles] delayed rescan failed: " + ex.GetType().Name + ": " + ex.Message));
			}
		}

		private void Update()
		{
			if (UltraBloodConfig.Enabled && UltraBloodConfig.RecolorPuddles && !UltraBloodConfig.SolidCyanTest && (UltraBloodConfig.RainbowBlood || UltraBloodConfig.EnemyBloodColorMatch))
			{
				BloodColorController.TickDynamicColor();
			}
		}

		private void OnDestroy()
		{
			BloodColorController.RestoreStainMaterials();
			BloodParticles.RestoreAll();
			Harmony harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}
	}
	internal enum BundleStatus
	{
		NotAttempted,
		Loaded,
		EmbeddedBundleResourceMissing,
		MultipleEmbeddedBundlesFound,
		BundleLoadFailed,
		ShaderNotFound,
		ShaderUnsupported,
		ShaderPassCountInvalid
	}
	internal static class ShaderBundle
	{
		private const string BundleResourceName = "UltraBlood.Resources.ultrablood-sbp.bundle";

		private const string ManifestResourceName = "UltraBlood.Resources.ultrablood-sbp.manifest.json";

		private const string ShaderName = "UltraBlood/CompositeBloodTint";

		private const string ProbeAssetName = "UltraBloodBundleProbe";

		private const string CompatibilityTestsFolder = "CompatibilityTests";

		private const string ExternalCompositeBundleName = "sbp-probe-composite.bundle";

		private const string RuntimeBundleFileName = "ultrablood-sbp.runtime.bundle";

		private static bool _attempted;

		private static AssetBundle _bundle;

		private static Shader _compositeShader;

		public static BundleStatus Status { get; private set; } = BundleStatus.NotAttempted;

		public static string StatusMessage { get; private set; } = "not attempted";

		public static string Source { get; private set; } = "none";

		public static Shader CompositeShader
		{
			get
			{
				if (!_attempted)
				{
					_attempted = true;
					try
					{
						Load();
					}
					catch (Exception ex)
					{
						Fail(BundleStatus.BundleLoadFailed, "exception: " + ex.GetType().Name + ": " + ex.Message);
						Plugin.Log.LogError((object)("[bundle] " + ex));
					}
				}
				return _compositeShader;
			}
		}

		private static void Load()
		{
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			Plugin.Log.LogInfo((object)("[bundle] assembly='" + executingAssembly.GetName().Name + "' location='" + executingAssembly.Location + "'"));
			string[] array = (from n in executingAssembly.GetManifestResourceNames()
				where n.IndexOf("ultrablood", StringComparison.OrdinalIgnoreCase) >= 0 && n.EndsWith(".bundle", StringComparison.OrdinalIgnoreCase)
				select n).ToArray();
			string[] array2 = array;
			foreach (string text in array2)
			{
				Plugin.Log.LogInfo((object)("[bundle] embedded bundle resource: " + text));
			}
			if (array.Length == 0)
			{
				Fail(BundleStatus.EmbeddedBundleResourceMissing, "no embedded *.bundle resource found");
				return;
			}
			if (array.Length > 1)
			{
				Fail(BundleStatus.MultipleEmbeddedBundlesFound, "multiple embedded bundle resources: " + string.Join(", ", array));
				return;
			}
			byte[] array3 = ReadResource(executingAssembly, "UltraBlood.Resources.ultrablood-sbp.bundle");
			if (array3 == null)
			{
				Fail(BundleStatus.EmbeddedBundleResourceMissing, "bundle resource stream missing: UltraBlood.Resources.ultrablood-sbp.bundle");
				return;
			}
			string text2 = Sha256Hex(array3);
			string arg = Encoding.ASCII.GetString(array3, 0, Math.Min(24, array3.Length)).Replace("\0", ".");
			Plugin.Log.LogInfo((object)$"[bundle] embedded bytes={array3.Length} sha256={text2} header='{arg}'");
			LogManifest(executingAssembly, array3.Length, text2);
			_bundle = LoadBundle(array3);
			if ((Object)(object)_bundle == (Object)null)
			{
				Fail(BundleStatus.BundleLoadFailed, "all load methods returned null");
				return;
			}
			string[] allAssetNames = _bundle.GetAllAssetNames();
			Plugin.Log.LogInfo((object)("[bundle] contains assets: " + string.Join(", ", allAssetNames)));
			TextAsset val = LoadFirst<TextAsset>(_bundle, "UltraBloodBundleProbe");
			Plugin.Log.LogInfo((object)(((Object)(object)val != (Object)null) ? ("[bundle] probe TextAsset loaded: \"" + val.text.Trim() + "\"") : "[bundle] probe TextAsset not found"));
			_compositeShader = LoadFirst<Shader>(_bundle, "UltraBlood/CompositeBloodTint");
			if ((Object)(object)_compositeShader == (Object)null)
			{
				Fail(BundleStatus.ShaderNotFound, "composite shader not found in bundle");
				return;
			}
			if (!_compositeShader.isSupported)
			{
				Fail(BundleStatus.ShaderUnsupported, $"shader '{((Object)_compositeShader).name}' is not supported on {SystemInfo.graphicsDeviceType}");
				return;
			}
			if (_compositeShader.passCount <= 1)
			{
				Fail(BundleStatus.ShaderPassCountInvalid, $"shader '{((Object)_compositeShader).name}' has passCount={_compositeShader.passCount}; the composite draws pass index 1");
				return;
			}
			Status = BundleStatus.Loaded;
			StatusMessage = "loaded from " + Source;
			Plugin.Log.LogInfo((object)$"[bundle] shader '{((Object)_compositeShader).name}' loaded from {Source}, supported=true, passCount={_compositeShader.passCount}");
		}

		private static AssetBundle LoadBundle(byte[] bytes)
		{
			string text = null;
			try
			{
				text = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
			}
			catch
			{
			}
			if (text != null)
			{
				string text2 = Path.Combine(text, "CompatibilityTests", "sbp-probe-composite.bundle");
				if (File.Exists(text2))
				{
					try
					{
						byte[] array = File.ReadAllBytes(text2);
						Plugin.Log.LogInfo((object)$"[bundle] external SBP bundle '{text2}' bytes={array.Length} sha256={Sha256Hex(array)}");
						AssetBundle val = AssetBundle.LoadFromFile(text2);
						Plugin.Log.LogInfo((object)("[bundle] external SBP LoadFromFile result: " + (((Object)(object)val != (Object)null) ? "loaded" : "null")));
						if ((Object)(object)val != (Object)null)
						{
							Source = "external:sbp-probe-composite.bundle";
							return val;
						}
					}
					catch (Exception ex)
					{
						Plugin.Log.LogWarning((object)("[bundle] external SBP load failed: " + ex.GetType().Name + ": " + ex.Message));
					}
				}
			}
			if (text != null)
			{
				try
				{
					string text3 = Path.Combine(text, "ultrablood-sbp.runtime.bundle");
					File.WriteAllBytes(text3, bytes);
					AssetBundle val2 = AssetBundle.LoadFromFile(text3);
					Plugin.Log.LogInfo((object)("[bundle] embedded SBP ->file LoadFromFile result: " + (((Object)(object)val2 != (Object)null) ? "loaded" : "null")));
					if ((Object)(object)val2 != (Object)null)
					{
						Source = "embedded-file";
						return val2;
					}
				}
				catch (Exception ex2)
				{
					Plugin.Log.LogWarning((object)("[bundle] embedded->file load failed: " + ex2.GetType().Name + ": " + ex2.Message));
				}
			}
			AssetBundle val3 = AssetBundle.LoadFromMemory(bytes);
			Plugin.Log.LogInfo((object)("[bundle] embedded SBP LoadFromMemory result: " + (((Object)(object)val3 != (Object)null) ? "loaded" : "null")));
			if ((Object)(object)val3 != (Object)null)
			{
				Source = "embedded-memory";
			}
			return val3;
		}

		private static T LoadFirst<T>(AssetBundle bundle, string preferredName) where T : Object
		{
			T val = bundle.LoadAsset<T>(preferredName);
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			T[] array = bundle.LoadAllAssets<T>();
			if (array == null || array.Length == 0)
			{
				return default(T);
			}
			return array[0];
		}

		private static void LogManifest(Assembly assembly, int actualLength, string actualHash)
		{
			byte[] array = ReadResource(assembly, "UltraBlood.Resources.ultrablood-sbp.manifest.json");
			if (array == null)
			{
				Plugin.Log.LogWarning((object)"[bundle] embedded manifest missing: UltraBlood.Resources.ultrablood-sbp.manifest.json");
				return;
			}
			string text = Encoding.UTF8.GetString(array);
			Plugin.Log.LogInfo((object)("[bundle] build manifest: " + text.Replace("\r", string.Empty).Replace("\n", " ")));
			string text2 = ExtractJsonString(text, "sha256");
			if (!string.IsNullOrEmpty(text2))
			{
				bool flag = string.Equals(text2, actualHash, StringComparison.OrdinalIgnoreCase);
				Plugin.Log.LogInfo((object)("[bundle] manifest sha256 " + (flag ? "matches" : "DOES NOT MATCH") + " embedded bytes (manifest=" + text2 + ", actual=" + actualHash + ")"));
			}
			string text3 = ExtractJsonString(text, "unityEditorVersion");
			if (!string.IsNullOrEmpty(text3))
			{
				Plugin.Log.LogInfo((object)("[bundle] built with Unity " + text3 + "; runtime is Unity " + Application.unityVersion));
			}
		}

		private static string ExtractJsonString(string json, string key)
		{
			Match match = Regex.Match(json, "\"" + Regex.Escape(key) + "\"\\s*:\\s*\"([^\"]*)\"");
			if (!match.Success)
			{
				return null;
			}
			return match.Groups[1].Value;
		}

		private static byte[] ReadResource(Assembly assembly, string name)
		{
			using Stream stream = assembly.GetManifestResourceStream(name);
			if (stream == null)
			{
				return null;
			}
			using MemoryStream memoryStream = new MemoryStream();
			stream.CopyTo(memoryStream);
			return memoryStream.ToArray();
		}

		private static string Sha256Hex(byte[] data)
		{
			using SHA256 sHA = SHA256.Create();
			byte[] array = sHA.ComputeHash(data);
			StringBuilder stringBuilder = new StringBuilder(array.Length * 2);
			byte[] array2 = array;
			foreach (byte b in array2)
			{
				stringBuilder.Append(b.ToString("X2"));
			}
			return stringBuilder.ToString();
		}

		private static void Fail(BundleStatus status, string message)
		{
			Status = status;
			StatusMessage = message;
			Plugin.Log.LogError((object)$"[bundle] {status}: {message}");
		}
	}
	internal static class UltraBloodConfig
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static PostBoolValueChangeEvent <>9__39_0;

			public static PostColorValueChangeEvent <>9__39_1;

			public static PostBoolValueChangeEvent <>9__39_2;

			public static PostBoolValueChangeEvent <>9__39_3;

			public static PostBoolValueChangeEvent <>9__39_4;

			public static PostBoolValueChangeEvent <>9__39_5;

			public static PostFloatValueChangeEvent <>9__39_6;

			public static PostBoolValueChangeEvent <>9__39_7;

			public static PostBoolValueChangeEvent <>9__39_8;

			public static PostBoolValueChangeEvent <>9__39_9;

			internal void <CreateMenu>b__39_0(bool _)
			{
				ScheduleReapply();
			}

			internal void <CreateMenu>b__39_1(Color _)
			{
				ScheduleReapply();
			}

			internal void <CreateMenu>b__39_2(bool _)
			{
				ScheduleReapply();
			}

			internal void <CreateMenu>b__39_3(bool _)
			{
				ScheduleReapply();
			}

			internal void <CreateMenu>b__39_4(bool _)
			{
				ScheduleReapply();
			}

			internal void <CreateMenu>b__39_5(bool _)
			{
				ScheduleReapply();
			}

			internal void <CreateMenu>b__39_6(float _)
			{
				ScheduleReapply();
			}

			internal void <CreateMenu>b__39_7(bool _)
			{
				ScheduleReapply();
			}

			internal void <CreateMenu>b__39_8(bool _)
			{
				ScheduleReapply();
			}

			internal void <CreateMenu>b__39_9(bool _)
			{
				UpdateInteractivity();
			}
		}

		public static readonly Color DefaultBloodColor = new Color(0.5f, 0f, 0f);

		public const float DefaultPuddleOpacity = 0.65f;

		private static PluginConfigurator _configurator;

		private static ManualLogSource _log;

		private static BoolField _enabledField;

		private static ColorField _bloodColorField;

		private static BoolField _rainbowField;

		private static BoolField _enemyMatchField;

		private static BoolField _recolorSplattersField;

		private static BoolField _recolorPuddlesField;

		private static FloatField _puddleOpacityField;

		private static BoolField _debugLoggingField;

		private static BoolField _solidCyanTestField;

		private static BoolField _solidCyanParticlesField;

		private static ConfigHeader _puddleStatusHeader;

		private static ConfigHeader _compatStatusHeader;

		private static bool _reconciling;

		private static readonly Color TitleColor = new Color(1f, 0.3f, 0.3f);

		private static readonly Color EnabledColor = new Color(0.86f, 0.4f, 0.4f);

		public static bool Enabled
		{
			get
			{
				if (_enabledField != null)
				{
					return _enabledField.value;
				}
				return true;
			}
		}

		public static Color BloodColor
		{
			get
			{
				//IL_0012: 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)
				if (_bloodColorField != null)
				{
					return _bloodColorField.value;
				}
				return DefaultBloodColor;
			}
		}

		public static bool RainbowBlood
		{
			get
			{
				if (_rainbowField != null)
				{
					return _rainbowField.value;
				}
				return false;
			}
		}

		public static bool EnemyBloodColorMatch
		{
			get
			{
				if (_enemyMatchField != null)
				{
					return _enemyMatchField.value;
				}
				return false;
			}
		}

		public static bool RecolorSplatters
		{
			get
			{
				if (_recolorSplattersField != null)
				{
					return _recolorSplattersField.value;
				}
				return true;
			}
		}

		public static bool RecolorPuddles
		{
			get
			{
				if (_recolorPuddlesField != null)
				{
					return _recolorPuddlesField.value;
				}
				return true;
			}
		}

		public static float PuddleOpacity
		{
			get
			{
				if (_puddleOpacityField != null)
				{
					return Mathf.Clamp01(_puddleOpacityField.value);
				}
				return 0.65f;
			}
		}

		public static bool DebugLogging
		{
			get
			{
				if (_debugLoggingField != null)
				{
					return _debugLoggingField.value;
				}
				return false;
			}
		}

		public static bool SolidCyanTest
		{
			get
			{
				if (_solidCyanTestField != null)
				{
					return _solidCyanTestField.value;
				}
				return false;
			}
		}

		public static bool SolidCyanParticles
		{
			get
			{
				if (_solidCyanParticlesField != null)
				{
					return _solidCyanParticlesField.value;
				}
				return false;
			}
		}

		public static void SetPuddleStatus(string text, bool ok)
		{
			//IL_0040: 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)
			if (_puddleStatusHeader != null)
			{
				_puddleStatusHeader.text = text;
				_puddleStatusHeader.textColor = (ok ? new Color(0.56f, 0.86f, 0.56f) : new Color(1f, 0.55f, 0f));
			}
		}

		public static void SetCompatStatus(string text, bool ok)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			if (_compatStatusHeader != null)
			{
				_compatStatusHeader.text = text;
				_compatStatusHeader.textColor = (Color)(ok ? new Color(0.56f, 0.86f, 0.56f) : Color.gray);
			}
		}

		public static void Initialize(ManualLogSource log)
		{
			_log = log;
			try
			{
				CreateMenu();
				_log.LogInfo((object)"Config menu initialized.");
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("PluginConfigurator menu could not be initialized: " + ex.GetType().Name + ": " + ex.Message));
			}
		}

		private static void CreateMenu()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			//IL_006c: 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_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			//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_0061: Expected O, but got Unknown
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Expected O, but got Unknown
			//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_00b5: Expected O, but got Unknown
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Expected O, but got Unknown
			//IL_0102: 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)
			//IL_010d: Expected O, but got Unknown
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Expected O, but got Unknown
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Expected O, but got Unknown
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Expected O, but got Unknown
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Expected O, but got Unknown
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Expected O, but got Unknown
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Expected O, but got Unknown
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: Expected O, but got Unknown
			//IL_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Expected O, but got Unknown
			//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0300: Expected O, but got Unknown
			//IL_02cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d8: Expected O, but got Unknown
			//IL_0342: Unknown result type (might be due to invalid IL or missing references)
			//IL_034c: Expected O, but got Unknown
			//IL_0319: Unknown result type (might be due to invalid IL or missing references)
			//IL_031e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0324: Expected O, but got Unknown
			//IL_0365: Unknown result type (might be due to invalid IL or missing references)
			//IL_036a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0370: Expected O, but got Unknown
			if (_configurator != null)
			{
				return;
			}
			_configurator = PluginConfigurator.Create("UltraBlood", "ultrablood.kiyroprower.ultrakill");
			ConfigPanel rootPanel = _configurator.rootPanel;
			_enabledField = new BoolField(rootPanel, "Enabled", "ultrablood.enabled", true, true);
			BoolField enabledField = _enabledField;
			object obj = <>c.<>9__39_0;
			if (obj == null)
			{
				PostBoolValueChangeEvent val = delegate
				{
					ScheduleReapply();
				};
				<>c.<>9__39_0 = val;
				obj = (object)val;
			}
			enabledField.postValueChangeEvent += (PostBoolValueChangeEvent)obj;
			AddDescription(rootPanel, "Recolor blood using the color below. Turn off to restore vanilla blood.", EnabledColor);
			_bloodColorField = new ColorField(rootPanel, "Blood Color", "ultrablood.color", DefaultBloodColor);
			ColorField bloodColorField = _bloodColorField;
			object obj2 = <>c.<>9__39_1;
			if (obj2 == null)
			{
				PostColorValueChangeEvent val2 = delegate
				{
					ScheduleReapply();
				};
				<>c.<>9__39_1 = val2;
				obj2 = (object)val2;
			}
			bloodColorField.postValueChangeEvent += (PostColorValueChangeEvent)obj2;
			AddDescription(rootPanel, "The color applied to blood. Its alpha is not used; puddle transparency is set by Puddle Opacity below.");
			AddTitle(rootPanel, "Color Mode");
			_rainbowField = new BoolField(rootPanel, "Rainbow Blood", "ultrablood.rainbow", false, true);
			BoolField rainbowField = _rainbowField;
			object obj3 = <>c.<>9__39_2;
			if (obj3 == null)
			{
				PostBoolValueChangeEvent val3 = delegate
				{
					ScheduleReapply();
				};
				<>c.<>9__39_2 = val3;
				obj3 = (object)val3;
			}
			rainbowField.postValueChangeEvent += (PostBoolValueChangeEvent)obj3;
			AddDescription(rootPanel, "Give each blood particle system a random color, and cycle puddle color through the rainbow. Replaces the Blood Color. Cannot be used with Enemy Blood Color Match.");
			_enemyMatchField = new BoolField(rootPanel, "Enemy Blood Color Match", "ultrablood.enemyMatch", false, true);
			BoolField enemyMatchField = _enemyMatchField;
			object obj4 = <>c.<>9__39_3;
			if (obj4 == null)
			{
				PostBoolValueChangeEvent val4 = delegate
				{
					ScheduleReapply();
				};
				<>c.<>9__39_3 = val4;
				obj4 = (object)val4;
			}
			enemyMatchField.postValueChangeEvent += (PostBoolValueChangeEvent)obj4;
			AddDescription(rootPanel, "Experimental. Recolor each enemy's blood to a curated color for that enemy. Puddles follow the last enemy that bled. Unmapped enemies use the Blood Color. Cannot be used with Rainbow Blood.");
			AddTitle(rootPanel, "What To Recolor");
			_recolorSplattersField = new BoolField(rootPanel, "Recolor Splatters", "ultrablood.splatters", true, true);
			BoolField recolorSplattersField = _recolorSplattersField;
			object obj5 = <>c.<>9__39_4;
			if (obj5 == null)
			{
				PostBoolValueChangeEvent val5 = delegate
				{
					ScheduleReapply();
				};
				<>c.<>9__39_4 = val5;
				obj5 = (object)val5;
			}
			recolorSplattersField.postValueChangeEvent += (PostBoolValueChangeEvent)obj5;
			AddDescription(rootPanel, "Tint the blood spray particles that burst from enemies. Sand, gold, and underwater variants are left alone.");
			_recolorPuddlesField = new BoolField(rootPanel, "Recolor Puddles", "ultrablood.puddles", true, true);
			BoolField recolorPuddlesField = _recolorPuddlesField;
			object obj6 = <>c.<>9__39_5;
			if (obj6 == null)
			{
				PostBoolValueChangeEvent val6 = delegate
				{
					ScheduleReapply();
				};
				<>c.<>9__39_5 = val6;
				obj6 = (object)val6;
			}
			recolorPuddlesField.postValueChangeEvent += (PostBoolValueChangeEvent)obj6;
			AddDescription(rootPanel, "Tint the bloodstains that pool on floors and walls.");
			_puddleOpacityField = new FloatField(rootPanel, "Puddle Opacity", "ultrablood.puddleOpacity", 0.65f, 0f, 1f);
			FloatField puddleOpacityField = _puddleOpacityField;
			object obj7 = <>c.<>9__39_6;
			if (obj7 == null)
			{
				PostFloatValueChangeEvent val7 = delegate
				{
					ScheduleReapply();
				};
				<>c.<>9__39_6 = val7;
				obj7 = (object)val7;
			}
			puddleOpacityField.postValueChangeEvent += (PostFloatValueChangeEvent)obj7;
			AddDescription(rootPanel, "How opaque recolored puddles are. Lower is more see-through, closer to vanilla blood. 1 is fully opaque.");
			_puddleStatusHeader = AddDescription(rootPanel, "Puddle recoloring status is reported here once in a level.", Color.gray);
			AddTitle(rootPanel, "Diagnostics");
			_compatStatusHeader = AddDescription(rootPanel, "Bundle compatibility test: not run.", Color.gray);
			_solidCyanTestField = new BoolField(rootPanel, "Solid Cyan Test (Puddles)", "ultrablood.solidCyan", false, true);
			BoolField solidCyanTestField = _solidCyanTestField;
			object obj8 = <>c.<>9__39_7;
			if (obj8 == null)
			{
				PostBoolValueChangeEvent val8 = delegate
				{
					ScheduleReapply();
				};
				<>c.<>9__39_7 = val8;
				obj8 = (object)val8;
			}
			solidCyanTestField.postValueChangeEvent += (PostBoolValueChangeEvent)obj8;
			AddDescription(rootPanel, "Force puddles to solid cyan, ignoring the color above. If puddles turn cyan the replacement shader is working. If they stay red it is not active.");
			_solidCyanParticlesField = new BoolField(rootPanel, "Solid Cyan Test (Impact Particles)", "ultrablood.solidCyanParticles", false, true);
			BoolField solidCyanParticlesField = _solidCyanParticlesField;
			object obj9 = <>c.<>9__39_8;
			if (obj9 == null)
			{
				PostBoolValueChangeEvent val9 = delegate
				{
					ScheduleReapply();
				};
				<>c.<>9__39_8 = val9;
				obj9 = (object)val9;
			}
			solidCyanParticlesField.postValueChangeEvent += (PostBoolValueChangeEvent)obj9;
			AddDescription(rootPanel, "Force blood impact particles to solid cyan. If the previously dark-red particles turn cyan they are being recolored. If they stay red another effect path remains.");
			_debugLoggingField = new BoolField(rootPanel, "Debug Logging", "ultrablood.debug", false, true);
			BoolField debugLoggingField = _debugLoggingField;
			object obj10 = <>c.<>9__39_9;
			if (obj10 == null)
			{
				PostBoolValueChangeEvent val10 = delegate
				{
					UpdateInteractivity();
				};
				<>c.<>9__39_9 = val10;
				obj10 = (object)val10;
			}
			debugLoggingField.postValueChangeEvent += (PostBoolValueChangeEvent)obj10;
			AddDescription(rootPanel, "Log the runtime environment, shader bundle loading, and material state to the BepInEx console.");
			ReconcileModes();
			UpdateInteractivity();
		}

		private static void UpdateInteractivity()
		{
			try
			{
				bool enabled = Enabled;
				bool flag = SolidCyanTest || SolidCyanParticles;
				bool enemyBloodColorMatch = EnemyBloodColorMatch;
				bool rainbowBlood = RainbowBlood;
				SetInteractable((ConfigField)(object)_bloodColorField, enabled && !flag && !enemyBloodColorMatch && !rainbowBlood);
				SetInteractable((ConfigField)(object)_rainbowField, enabled && !flag && !enemyBloodColorMatch);
				SetInteractable((ConfigField)(object)_enemyMatchField, enabled && !flag && !rainbowBlood);
				SetInteractable((ConfigField)(object)_solidCyanTestField, enabled);
				SetInteractable((ConfigField)(object)_solidCyanParticlesField, enabled);
				SetInteractable((ConfigField)(object)_recolorSplattersField, enabled);
				SetInteractable((ConfigField)(object)_recolorPuddlesField, enabled);
				SetInteractable((ConfigField)(object)_puddleOpacityField, enabled);
				SetInteractable((ConfigField)(object)_debugLoggingField, enabled);
			}
			catch (Exception ex)
			{
				ManualLogSource log = _log;
				if (log != null)
				{
					log.LogWarning((object)("Failed to update config interactivity: " + ex.GetType().Name + ": " + ex.Message));
				}
			}
		}

		private static void SetInteractable(ConfigField field, bool value)
		{
			if (field != null && field.interactable != value)
			{
				field.interactable = value;
			}
		}

		private static void ScheduleReapply()
		{
			ReconcileModes();
			UpdateInteractivity();
			BloodColorController.Refresh();
			BloodParticles.ReapplyAll();
		}

		private static void ReconcileModes()
		{
			if (_reconciling || _rainbowField == null || _enemyMatchField == null || !_enemyMatchField.value || !_rainbowField.value)
			{
				return;
			}
			_reconciling = true;
			try
			{
				_rainbowField.value = false;
			}
			finally
			{
				_reconciling = false;
			}
		}

		private static ConfigHeader AddTitle(ConfigPanel panel, string text)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Expected O, but got Unknown
			return new ConfigHeader(panel, text, 18)
			{
				textColor = TitleColor
			};
		}

		private static ConfigHeader AddDescription(ConfigPanel panel, string text)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return AddDescription(panel, text, Color.gray);
		}

		private static ConfigHeader AddDescription(ConfigPanel panel, string text, Color color)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			return new ConfigHeader(panel, text, 14)
			{
				textColor = color
			};
		}
	}
}